ShizZy
12 years ago
54 changed files with 8640 additions and 163 deletions
-
56akiru.sln
-
185src/common/common.vcxproj
-
68src/common/common.vcxproj.filters
-
19src/common/src/atomic.h
-
113src/common/src/atomic_gcc.h
-
72src/common/src/atomic_win32.h
-
203src/common/src/break_points.cpp
-
102src/common/src/break_points.h
-
384src/common/src/chunk_file.h
-
164src/common/src/common.h
-
243src/common/src/common_funcs.h
-
71src/common/src/common_paths.h
-
48src/common/src/common_types.h
-
337src/common/src/console_listener.cpp
-
41src/common/src/console_listener.h
-
81src/common/src/cpu_detect.h
-
39src/common/src/debug_interface.h
-
433src/common/src/extended_trace.cpp
-
53src/common/src/extended_trace.h
-
115src/common/src/fifo_queue.h
-
106src/common/src/file_search.cpp
-
28src/common/src/file_search.h
-
922src/common/src/file_util.cpp
-
232src/common/src/file_util.h
-
75src/common/src/fixed_size_queue.h
-
520src/common/src/hash.cpp
-
20src/common/src/hash.h
-
191src/common/src/linear_disk_cache.h
-
155src/common/src/log.h
-
199src/common/src/log_manager.cpp
-
169src/common/src/log_manager.h
-
212src/common/src/math_util.cpp
-
200src/common/src/math_util.h
-
304src/common/src/mem_arena.cpp
-
58src/common/src/mem_arena.h
-
197src/common/src/memory_util.cpp
-
25src/common/src/memory_util.h
-
33src/common/src/misc.cpp
-
107src/common/src/msg_handler.cpp
-
73src/common/src/msg_handler.h
-
4src/common/src/scm_rev.h
-
170src/common/src/std_condition_variable.h
-
365src/common/src/std_mutex.h
-
317src/common/src/std_thread.h
-
531src/common/src/string_util.cpp
-
111src/common/src/string_util.h
-
133src/common/src/thread.cpp
-
156src/common/src/thread.h
-
46src/common/src/thunk.h
-
226src/common/src/timer.cpp
-
46src/common/src/timer.h
-
45src/common/src/version.cpp
-
0vsprops/code_generation_debug.props
-
0vsprops/code_generation_release.props
@ -1,35 +1,59 @@ |
|||||
<?xml version="1.0" encoding="utf-8"?> |
<?xml version="1.0" encoding="utf-8"?> |
||||
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> |
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> |
||||
<ItemGroup> |
<ItemGroup> |
||||
<ClCompile Include="src\crc.cpp" /> |
|
||||
<ClCompile Include="src\log.cpp" /> |
|
||||
<ClCompile Include="src\timer.cpp" /> |
|
||||
<ClCompile Include="src\xml.cpp" /> |
|
||||
<ClCompile Include="src\config.cpp" /> |
|
||||
<ClCompile Include="src\misc_utils.cpp" /> |
|
||||
|
<ClCompile Include="src\break_points.cpp" /> |
||||
|
<ClCompile Include="src\console_listener.cpp" /> |
||||
|
<ClCompile Include="src\extended_trace.cpp" /> |
||||
|
<ClCompile Include="src\file_search.cpp" /> |
||||
|
<ClCompile Include="src\file_util.cpp" /> |
||||
<ClCompile Include="src\hash.cpp" /> |
<ClCompile Include="src\hash.cpp" /> |
||||
<ClCompile Include="src\x86_utils.cpp" /> |
|
||||
<ClCompile Include="src\file_utils.cpp" /> |
|
||||
|
<ClCompile Include="src\log_manager.cpp" /> |
||||
|
<ClCompile Include="src\math_util.cpp" /> |
||||
|
<ClCompile Include="src\memory_util.cpp" /> |
||||
|
<ClCompile Include="src\mem_arena.cpp" /> |
||||
|
<ClCompile Include="src\misc.cpp" /> |
||||
|
<ClCompile Include="src\msg_handler.cpp" /> |
||||
|
<ClCompile Include="src\string_util.cpp" /> |
||||
|
<ClCompile Include="src\thread.cpp" /> |
||||
|
<ClCompile Include="src\timer.cpp" /> |
||||
|
<ClCompile Include="src\version.cpp" /> |
||||
</ItemGroup> |
</ItemGroup> |
||||
<ItemGroup> |
<ItemGroup> |
||||
<ClInclude Include="src\crc.h" /> |
|
||||
<ClInclude Include="src\platform.h" /> |
|
||||
|
<ClInclude Include="src\atomic.h" /> |
||||
|
<ClInclude Include="src\break_points.h" /> |
||||
|
<ClInclude Include="src\chunk_file.h" /> |
||||
<ClInclude Include="src\common.h" /> |
<ClInclude Include="src\common.h" /> |
||||
<ClInclude Include="src\types.h" /> |
|
||||
|
<ClInclude Include="src\common_funcs.h" /> |
||||
|
<ClInclude Include="src\common_paths.h" /> |
||||
|
<ClInclude Include="src\common_types.h" /> |
||||
|
<ClInclude Include="src\console_listener.h" /> |
||||
|
<ClInclude Include="src\cpu_detect.h" /> |
||||
|
<ClInclude Include="src\debug_interface.h" /> |
||||
|
<ClInclude Include="src\extended_trace.h" /> |
||||
|
<ClInclude Include="src\fifo_queue.h" /> |
||||
|
<ClInclude Include="src\file_search.h" /> |
||||
|
<ClInclude Include="src\file_util.h" /> |
||||
|
<ClInclude Include="src\fixed_size_queue.h" /> |
||||
|
<ClInclude Include="src\hash.h" /> |
||||
|
<ClInclude Include="src\linear_disk_cache.h" /> |
||||
<ClInclude Include="src\log.h" /> |
<ClInclude Include="src\log.h" /> |
||||
<ClInclude Include="src\timer.h" /> |
|
||||
<ClInclude Include="src\x86_utils.h" /> |
|
||||
<ClInclude Include="src\config.h" /> |
|
||||
<ClInclude Include="src\xml.h" /> |
|
||||
<ClInclude Include="src\misc_utils.h" /> |
|
||||
<ClInclude Include="src\atomic.h" /> |
|
||||
<ClInclude Include="src\atomic_win32.h" /> |
|
||||
<ClInclude Include="src\atomic_gcc.h" /> |
|
||||
|
<ClInclude Include="src\log_manager.h" /> |
||||
|
<ClInclude Include="src\math_util.h" /> |
||||
|
<ClInclude Include="src\memory_util.h" /> |
||||
|
<ClInclude Include="src\mem_arena.h" /> |
||||
|
<ClInclude Include="src\msg_handler.h" /> |
||||
|
<ClInclude Include="src\scm_rev.h" /> |
||||
<ClInclude Include="src\std_condition_variable.h" /> |
<ClInclude Include="src\std_condition_variable.h" /> |
||||
<ClInclude Include="src\std_mutex.h" /> |
<ClInclude Include="src\std_mutex.h" /> |
||||
<ClInclude Include="src\std_thread.h" /> |
<ClInclude Include="src\std_thread.h" /> |
||||
<ClInclude Include="src\hash_container.h" /> |
|
||||
<ClInclude Include="src\hash.h" /> |
|
||||
<ClInclude Include="src\file_utils.h" /> |
|
||||
|
<ClInclude Include="src\string_util.h" /> |
||||
|
<ClInclude Include="src\thread.h" /> |
||||
|
<ClInclude Include="src\thunk.h" /> |
||||
|
<ClInclude Include="src\timer.h" /> |
||||
|
<ClInclude Include="src\atomic_gcc.h" /> |
||||
|
<ClInclude Include="src\atomic_win32.h" /> |
||||
|
</ItemGroup> |
||||
|
<ItemGroup> |
||||
|
<None Include="CMakeLists.txt" /> |
||||
</ItemGroup> |
</ItemGroup> |
||||
</Project> |
</Project> |
||||
@ -0,0 +1,19 @@ |
|||||
|
// Copyright 2013 Dolphin Emulator Project |
||||
|
// Licensed under GPLv2 |
||||
|
// Refer to the license.txt file included. |
||||
|
|
||||
|
#ifndef _ATOMIC_H_ |
||||
|
#define _ATOMIC_H_ |
||||
|
|
||||
|
#ifdef _WIN32 |
||||
|
|
||||
|
#include "atomic_win32.h" |
||||
|
|
||||
|
#else |
||||
|
|
||||
|
// GCC-compatible compiler assumed! |
||||
|
#include "atomic_gcc.h" |
||||
|
|
||||
|
#endif |
||||
|
|
||||
|
#endif |
||||
@ -0,0 +1,113 @@ |
|||||
|
// Copyright 2013 Dolphin Emulator Project |
||||
|
// Licensed under GPLv2 |
||||
|
// Refer to the license.txt file included. |
||||
|
|
||||
|
#ifndef _ATOMIC_GCC_H_ |
||||
|
#define _ATOMIC_GCC_H_ |
||||
|
|
||||
|
#include "common.h" |
||||
|
|
||||
|
// Atomic operations are performed in a single step by the CPU. It is |
||||
|
// impossible for other threads to see the operation "half-done." |
||||
|
// |
||||
|
// Some atomic operations can be combined with different types of memory |
||||
|
// barriers called "Acquire semantics" and "Release semantics", defined below. |
||||
|
// |
||||
|
// Acquire semantics: Future memory accesses cannot be relocated to before the |
||||
|
// operation. |
||||
|
// |
||||
|
// Release semantics: Past memory accesses cannot be relocated to after the |
||||
|
// operation. |
||||
|
// |
||||
|
// These barriers affect not only the compiler, but also the CPU. |
||||
|
|
||||
|
namespace Common |
||||
|
{ |
||||
|
|
||||
|
inline void AtomicAdd(volatile u32& target, u32 value) { |
||||
|
__sync_add_and_fetch(&target, value); |
||||
|
} |
||||
|
|
||||
|
inline void AtomicAnd(volatile u32& target, u32 value) { |
||||
|
__sync_and_and_fetch(&target, value); |
||||
|
} |
||||
|
|
||||
|
inline void AtomicDecrement(volatile u32& target) { |
||||
|
__sync_add_and_fetch(&target, -1); |
||||
|
} |
||||
|
|
||||
|
inline void AtomicIncrement(volatile u32& target) { |
||||
|
__sync_add_and_fetch(&target, 1); |
||||
|
} |
||||
|
|
||||
|
inline u32 AtomicLoad(volatile u32& src) { |
||||
|
return src; // 32-bit reads are always atomic. |
||||
|
} |
||||
|
inline u32 AtomicLoadAcquire(volatile u32& src) { |
||||
|
//keep the compiler from caching any memory references |
||||
|
u32 result = src; // 32-bit reads are always atomic. |
||||
|
//__sync_synchronize(); // TODO: May not be necessary. |
||||
|
// Compiler instruction only. x86 loads always have acquire semantics. |
||||
|
__asm__ __volatile__ ( "":::"memory" ); |
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
inline void AtomicOr(volatile u32& target, u32 value) { |
||||
|
__sync_or_and_fetch(&target, value); |
||||
|
} |
||||
|
|
||||
|
inline void AtomicStore(volatile u32& dest, u32 value) { |
||||
|
dest = value; // 32-bit writes are always atomic. |
||||
|
} |
||||
|
inline void AtomicStoreRelease(volatile u32& dest, u32 value) { |
||||
|
__sync_lock_test_and_set(&dest, value); // TODO: Wrong! This function is has acquire semantics. |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
|
||||
|
// Old code kept here for reference in case we need the parts with __asm__ __volatile__. |
||||
|
#if 0 |
||||
|
LONG SyncInterlockedIncrement(LONG *Dest) |
||||
|
{ |
||||
|
#if defined(__GNUC__) && defined (__GNUC_MINOR__) && ((4 < __GNUC__) || (4 == __GNUC__ && 1 <= __GNUC_MINOR__)) |
||||
|
return __sync_add_and_fetch(Dest, 1); |
||||
|
#else |
||||
|
register int result; |
||||
|
__asm__ __volatile__("lock; xadd %0,%1" |
||||
|
: "=r" (result), "=m" (*Dest) |
||||
|
: "0" (1), "m" (*Dest) |
||||
|
: "memory"); |
||||
|
return result; |
||||
|
#endif |
||||
|
} |
||||
|
|
||||
|
LONG SyncInterlockedExchangeAdd(LONG *Dest, LONG Val) |
||||
|
{ |
||||
|
#if defined(__GNUC__) && defined (__GNUC_MINOR__) && ((4 < __GNUC__) || (4 == __GNUC__ && 1 <= __GNUC_MINOR__)) |
||||
|
return __sync_add_and_fetch(Dest, Val); |
||||
|
#else |
||||
|
register int result; |
||||
|
__asm__ __volatile__("lock; xadd %0,%1" |
||||
|
: "=r" (result), "=m" (*Dest) |
||||
|
: "0" (Val), "m" (*Dest) |
||||
|
: "memory"); |
||||
|
return result; |
||||
|
#endif |
||||
|
} |
||||
|
|
||||
|
LONG SyncInterlockedExchange(LONG *Dest, LONG Val) |
||||
|
{ |
||||
|
#if defined(__GNUC__) && defined (__GNUC_MINOR__) && ((4 < __GNUC__) || (4 == __GNUC__ && 1 <= __GNUC_MINOR__)) |
||||
|
return __sync_lock_test_and_set(Dest, Val); |
||||
|
#else |
||||
|
register int result; |
||||
|
__asm__ __volatile__("lock; xchg %0,%1" |
||||
|
: "=r" (result), "=m" (*Dest) |
||||
|
: "0" (Val), "m" (*Dest) |
||||
|
: "memory"); |
||||
|
return result; |
||||
|
#endif |
||||
|
} |
||||
|
#endif |
||||
|
|
||||
|
#endif |
||||
@ -0,0 +1,72 @@ |
|||||
|
// Copyright 2013 Dolphin Emulator Project |
||||
|
// Licensed under GPLv2 |
||||
|
// Refer to the license.txt file included. |
||||
|
|
||||
|
#ifndef _ATOMIC_WIN32_H_ |
||||
|
#define _ATOMIC_WIN32_H_ |
||||
|
|
||||
|
#include "common.h" |
||||
|
#include <intrin.h> |
||||
|
#include <Windows.h> |
||||
|
|
||||
|
// Atomic operations are performed in a single step by the CPU. It is |
||||
|
// impossible for other threads to see the operation "half-done." |
||||
|
// |
||||
|
// Some atomic operations can be combined with different types of memory |
||||
|
// barriers called "Acquire semantics" and "Release semantics", defined below. |
||||
|
// |
||||
|
// Acquire semantics: Future memory accesses cannot be relocated to before the |
||||
|
// operation. |
||||
|
// |
||||
|
// Release semantics: Past memory accesses cannot be relocated to after the |
||||
|
// operation. |
||||
|
// |
||||
|
// These barriers affect not only the compiler, but also the CPU. |
||||
|
// |
||||
|
// NOTE: Acquire and Release are not differentiated right now. They perform a |
||||
|
// full memory barrier instead of a "one-way" memory barrier. The newest |
||||
|
// Windows SDK has Acquire and Release versions of some Interlocked* functions. |
||||
|
|
||||
|
namespace Common |
||||
|
{ |
||||
|
|
||||
|
inline void AtomicAdd(volatile u32& target, u32 value) { |
||||
|
InterlockedExchangeAdd((volatile LONG*)&target, (LONG)value); |
||||
|
} |
||||
|
|
||||
|
inline void AtomicAnd(volatile u32& target, u32 value) { |
||||
|
_InterlockedAnd((volatile LONG*)&target, (LONG)value); |
||||
|
} |
||||
|
|
||||
|
inline void AtomicIncrement(volatile u32& target) { |
||||
|
InterlockedIncrement((volatile LONG*)&target); |
||||
|
} |
||||
|
|
||||
|
inline void AtomicDecrement(volatile u32& target) { |
||||
|
InterlockedDecrement((volatile LONG*)&target); |
||||
|
} |
||||
|
|
||||
|
inline u32 AtomicLoad(volatile u32& src) { |
||||
|
return src; // 32-bit reads are always atomic. |
||||
|
} |
||||
|
inline u32 AtomicLoadAcquire(volatile u32& src) { |
||||
|
u32 result = src; // 32-bit reads are always atomic. |
||||
|
_ReadBarrier(); // Compiler instruction only. x86 loads always have acquire semantics. |
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
inline void AtomicOr(volatile u32& target, u32 value) { |
||||
|
_InterlockedOr((volatile LONG*)&target, (LONG)value); |
||||
|
} |
||||
|
|
||||
|
inline void AtomicStore(volatile u32& dest, u32 value) { |
||||
|
dest = value; // 32-bit writes are always atomic. |
||||
|
} |
||||
|
inline void AtomicStoreRelease(volatile u32& dest, u32 value) { |
||||
|
_WriteBarrier(); // Compiler instruction only. x86 stores always have release semantics. |
||||
|
dest = value; // 32-bit writes are always atomic. |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
|
||||
|
#endif |
||||
@ -0,0 +1,203 @@ |
|||||
|
// Copyright 2013 Dolphin Emulator Project
|
||||
|
// Licensed under GPLv2
|
||||
|
// Refer to the license.txt file included.
|
||||
|
|
||||
|
#include "common.h"
|
||||
|
#include "debug_interface.h"
|
||||
|
#include "break_points.h"
|
||||
|
|
||||
|
#include <sstream>
|
||||
|
#include <algorithm>
|
||||
|
|
||||
|
bool BreakPoints::IsAddressBreakPoint(u32 _iAddress) |
||||
|
{ |
||||
|
for (TBreakPoints::iterator i = m_BreakPoints.begin(); i != m_BreakPoints.end(); ++i) |
||||
|
if (i->iAddress == _iAddress) |
||||
|
return true; |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
bool BreakPoints::IsTempBreakPoint(u32 _iAddress) |
||||
|
{ |
||||
|
for (TBreakPoints::iterator i = m_BreakPoints.begin(); i != m_BreakPoints.end(); ++i) |
||||
|
if (i->iAddress == _iAddress && i->bTemporary) |
||||
|
return true; |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
BreakPoints::TBreakPointsStr BreakPoints::GetStrings() const |
||||
|
{ |
||||
|
TBreakPointsStr bps; |
||||
|
for (TBreakPoints::const_iterator i = m_BreakPoints.begin(); |
||||
|
i != m_BreakPoints.end(); ++i) |
||||
|
{ |
||||
|
if (!i->bTemporary) |
||||
|
{ |
||||
|
std::stringstream bp; |
||||
|
bp << std::hex << i->iAddress << " " << (i->bOn ? "n" : ""); |
||||
|
bps.push_back(bp.str()); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return bps; |
||||
|
} |
||||
|
|
||||
|
void BreakPoints::AddFromStrings(const TBreakPointsStr& bps) |
||||
|
{ |
||||
|
for (TBreakPointsStr::const_iterator i = bps.begin(); i != bps.end(); ++i) |
||||
|
{ |
||||
|
TBreakPoint bp; |
||||
|
std::stringstream bpstr; |
||||
|
bpstr << std::hex << *i; |
||||
|
bpstr >> bp.iAddress; |
||||
|
bp.bOn = i->find("n") != i->npos; |
||||
|
bp.bTemporary = false; |
||||
|
Add(bp); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
void BreakPoints::Add(const TBreakPoint& bp) |
||||
|
{ |
||||
|
if (!IsAddressBreakPoint(bp.iAddress)) |
||||
|
{ |
||||
|
m_BreakPoints.push_back(bp); |
||||
|
//if (jit)
|
||||
|
// jit->GetBlockCache()->InvalidateICache(bp.iAddress, 4);
|
||||
|
} |
||||
|
} |
||||
|
|
||||
|
void BreakPoints::Add(u32 em_address, bool temp) |
||||
|
{ |
||||
|
if (!IsAddressBreakPoint(em_address)) // only add new addresses
|
||||
|
{ |
||||
|
TBreakPoint pt; // breakpoint settings
|
||||
|
pt.bOn = true; |
||||
|
pt.bTemporary = temp; |
||||
|
pt.iAddress = em_address; |
||||
|
|
||||
|
m_BreakPoints.push_back(pt); |
||||
|
|
||||
|
//if (jit)
|
||||
|
// jit->GetBlockCache()->InvalidateICache(em_address, 4);
|
||||
|
} |
||||
|
} |
||||
|
|
||||
|
void BreakPoints::Remove(u32 em_address) |
||||
|
{ |
||||
|
for (TBreakPoints::iterator i = m_BreakPoints.begin(); i != m_BreakPoints.end(); ++i) |
||||
|
{ |
||||
|
if (i->iAddress == em_address) |
||||
|
{ |
||||
|
m_BreakPoints.erase(i); |
||||
|
//if (jit)
|
||||
|
// jit->GetBlockCache()->InvalidateICache(em_address, 4);
|
||||
|
return; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
void BreakPoints::Clear() |
||||
|
{ |
||||
|
//if (jit)
|
||||
|
//{
|
||||
|
// std::for_each(m_BreakPoints.begin(), m_BreakPoints.end(),
|
||||
|
// [](const TBreakPoint& bp)
|
||||
|
// {
|
||||
|
// jit->GetBlockCache()->InvalidateICache(bp.iAddress, 4);
|
||||
|
// }
|
||||
|
// );
|
||||
|
//}
|
||||
|
|
||||
|
m_BreakPoints.clear(); |
||||
|
} |
||||
|
|
||||
|
MemChecks::TMemChecksStr MemChecks::GetStrings() const |
||||
|
{ |
||||
|
TMemChecksStr mcs; |
||||
|
for (TMemChecks::const_iterator i = m_MemChecks.begin(); |
||||
|
i != m_MemChecks.end(); ++i) |
||||
|
{ |
||||
|
std::stringstream mc; |
||||
|
mc << std::hex << i->StartAddress; |
||||
|
mc << " " << (i->bRange ? i->EndAddress : i->StartAddress) << " " << |
||||
|
(i->bRange ? "n" : "") << (i->OnRead ? "r" : "") << |
||||
|
(i->OnWrite ? "w" : "") << (i->Log ? "l" : "") << (i->Break ? "p" : ""); |
||||
|
mcs.push_back(mc.str()); |
||||
|
} |
||||
|
|
||||
|
return mcs; |
||||
|
} |
||||
|
|
||||
|
void MemChecks::AddFromStrings(const TMemChecksStr& mcs) |
||||
|
{ |
||||
|
for (TMemChecksStr::const_iterator i = mcs.begin(); i != mcs.end(); ++i) |
||||
|
{ |
||||
|
TMemCheck mc; |
||||
|
std::stringstream mcstr; |
||||
|
mcstr << std::hex << *i; |
||||
|
mcstr >> mc.StartAddress; |
||||
|
mc.bRange = i->find("n") != i->npos; |
||||
|
mc.OnRead = i->find("r") != i->npos; |
||||
|
mc.OnWrite = i->find("w") != i->npos; |
||||
|
mc.Log = i->find("l") != i->npos; |
||||
|
mc.Break = i->find("p") != i->npos; |
||||
|
if (mc.bRange) |
||||
|
mcstr >> mc.EndAddress; |
||||
|
else |
||||
|
mc.EndAddress = mc.StartAddress; |
||||
|
Add(mc); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
void MemChecks::Add(const TMemCheck& _rMemoryCheck) |
||||
|
{ |
||||
|
if (GetMemCheck(_rMemoryCheck.StartAddress) == 0) |
||||
|
m_MemChecks.push_back(_rMemoryCheck); |
||||
|
} |
||||
|
|
||||
|
void MemChecks::Remove(u32 _Address) |
||||
|
{ |
||||
|
for (TMemChecks::iterator i = m_MemChecks.begin(); i != m_MemChecks.end(); ++i) |
||||
|
{ |
||||
|
if (i->StartAddress == _Address) |
||||
|
{ |
||||
|
m_MemChecks.erase(i); |
||||
|
return; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
TMemCheck *MemChecks::GetMemCheck(u32 address) |
||||
|
{ |
||||
|
for (TMemChecks::iterator i = m_MemChecks.begin(); i != m_MemChecks.end(); ++i) |
||||
|
{ |
||||
|
if (i->bRange) |
||||
|
{ |
||||
|
if (address >= i->StartAddress && address <= i->EndAddress) |
||||
|
return &(*i); |
||||
|
} |
||||
|
else if (i->StartAddress == address) |
||||
|
return &(*i); |
||||
|
} |
||||
|
|
||||
|
// none found
|
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
|
void TMemCheck::Action(DebugInterface *debug_interface, u32 iValue, u32 addr, |
||||
|
bool write, int size, u32 pc) |
||||
|
{ |
||||
|
if ((write && OnWrite) || (!write && OnRead)) |
||||
|
{ |
||||
|
if (Log) |
||||
|
{ |
||||
|
INFO_LOG(MEMMAP, "CHK %08x (%s) %s%i %0*x at %08x (%s)", |
||||
|
pc, debug_interface->getDescription(pc).c_str(), |
||||
|
write ? "Write" : "Read", size*8, size*2, iValue, addr, |
||||
|
debug_interface->getDescription(addr).c_str() |
||||
|
); |
||||
|
} |
||||
|
if (Break) |
||||
|
debug_interface->breakNow(); |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,102 @@ |
|||||
|
// Copyright 2013 Dolphin Emulator Project |
||||
|
// Licensed under GPLv2 |
||||
|
// Refer to the license.txt file included. |
||||
|
|
||||
|
#ifndef _DEBUGGER_BREAKPOINTS_H |
||||
|
#define _DEBUGGER_BREAKPOINTS_H |
||||
|
|
||||
|
#include <vector> |
||||
|
#include <string> |
||||
|
|
||||
|
#include "common.h" |
||||
|
|
||||
|
class DebugInterface; |
||||
|
|
||||
|
struct TBreakPoint |
||||
|
{ |
||||
|
u32 iAddress; |
||||
|
bool bOn; |
||||
|
bool bTemporary; |
||||
|
}; |
||||
|
|
||||
|
struct TMemCheck |
||||
|
{ |
||||
|
TMemCheck() { |
||||
|
numHits = 0; |
||||
|
StartAddress = EndAddress = 0; |
||||
|
bRange = OnRead = OnWrite = Log = Break = false; |
||||
|
} |
||||
|
u32 StartAddress; |
||||
|
u32 EndAddress; |
||||
|
|
||||
|
bool bRange; |
||||
|
|
||||
|
bool OnRead; |
||||
|
bool OnWrite; |
||||
|
|
||||
|
bool Log; |
||||
|
bool Break; |
||||
|
|
||||
|
u32 numHits; |
||||
|
|
||||
|
void Action(DebugInterface *dbg_interface, u32 _iValue, u32 addr, |
||||
|
bool write, int size, u32 pc); |
||||
|
}; |
||||
|
|
||||
|
// Code breakpoints. |
||||
|
class BreakPoints |
||||
|
{ |
||||
|
public: |
||||
|
typedef std::vector<TBreakPoint> TBreakPoints; |
||||
|
typedef std::vector<std::string> TBreakPointsStr; |
||||
|
|
||||
|
const TBreakPoints& GetBreakPoints() { return m_BreakPoints; } |
||||
|
|
||||
|
TBreakPointsStr GetStrings() const; |
||||
|
void AddFromStrings(const TBreakPointsStr& bps); |
||||
|
|
||||
|
// is address breakpoint |
||||
|
bool IsAddressBreakPoint(u32 _iAddress); |
||||
|
bool IsTempBreakPoint(u32 _iAddress); |
||||
|
|
||||
|
// Add BreakPoint |
||||
|
void Add(u32 em_address, bool temp=false); |
||||
|
void Add(const TBreakPoint& bp); |
||||
|
|
||||
|
// Remove Breakpoint |
||||
|
void Remove(u32 _iAddress); |
||||
|
void Clear(); |
||||
|
|
||||
|
void DeleteByAddress(u32 _Address); |
||||
|
|
||||
|
private: |
||||
|
TBreakPoints m_BreakPoints; |
||||
|
u32 m_iBreakOnCount; |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
// Memory breakpoints |
||||
|
class MemChecks |
||||
|
{ |
||||
|
public: |
||||
|
typedef std::vector<TMemCheck> TMemChecks; |
||||
|
typedef std::vector<std::string> TMemChecksStr; |
||||
|
|
||||
|
TMemChecks m_MemChecks; |
||||
|
|
||||
|
const TMemChecks& GetMemChecks() { return m_MemChecks; } |
||||
|
|
||||
|
TMemChecksStr GetStrings() const; |
||||
|
void AddFromStrings(const TMemChecksStr& mcs); |
||||
|
|
||||
|
void Add(const TMemCheck& _rMemoryCheck); |
||||
|
|
||||
|
// memory breakpoint |
||||
|
TMemCheck *GetMemCheck(u32 address); |
||||
|
void Remove(u32 _Address); |
||||
|
|
||||
|
void Clear() { m_MemChecks.clear(); }; |
||||
|
}; |
||||
|
|
||||
|
#endif |
||||
|
|
||||
@ -0,0 +1,384 @@ |
|||||
|
// Copyright 2013 Dolphin Emulator Project |
||||
|
// Licensed under GPLv2 |
||||
|
// Refer to the license.txt file included. |
||||
|
|
||||
|
|
||||
|
#ifndef _POINTERWRAP_H_ |
||||
|
#define _POINTERWRAP_H_ |
||||
|
|
||||
|
// Extremely simple serialization framework. |
||||
|
|
||||
|
// (mis)-features: |
||||
|
// + Super fast |
||||
|
// + Very simple |
||||
|
// + Same code is used for serialization and deserializaition (in most cases) |
||||
|
// - Zero backwards/forwards compatibility |
||||
|
// - Serialization code for anything complex has to be manually written. |
||||
|
|
||||
|
#include <map> |
||||
|
#include <vector> |
||||
|
#include <list> |
||||
|
#include <deque> |
||||
|
#include <string> |
||||
|
#include <type_traits> |
||||
|
|
||||
|
#include "common.h" |
||||
|
#include "file_util.h" |
||||
|
|
||||
|
template <class T> |
||||
|
struct LinkedListItem : public T |
||||
|
{ |
||||
|
LinkedListItem<T> *next; |
||||
|
}; |
||||
|
|
||||
|
// Wrapper class |
||||
|
class PointerWrap |
||||
|
{ |
||||
|
public: |
||||
|
enum Mode |
||||
|
{ |
||||
|
MODE_READ = 1, // load |
||||
|
MODE_WRITE, // save |
||||
|
MODE_MEASURE, // calculate size |
||||
|
MODE_VERIFY, // compare |
||||
|
}; |
||||
|
|
||||
|
u8 **ptr; |
||||
|
Mode mode; |
||||
|
|
||||
|
public: |
||||
|
PointerWrap(u8 **ptr_, Mode mode_) : ptr(ptr_), mode(mode_) {} |
||||
|
|
||||
|
void SetMode(Mode mode_) { mode = mode_; } |
||||
|
Mode GetMode() const { return mode; } |
||||
|
u8** GetPPtr() { return ptr; } |
||||
|
|
||||
|
template <typename K, class V> |
||||
|
void Do(std::map<K, V>& x) |
||||
|
{ |
||||
|
u32 count = (u32)x.size(); |
||||
|
Do(count); |
||||
|
|
||||
|
switch (mode) |
||||
|
{ |
||||
|
case MODE_READ: |
||||
|
for (x.clear(); count != 0; --count) |
||||
|
{ |
||||
|
std::pair<K, V> pair; |
||||
|
Do(pair.first); |
||||
|
Do(pair.second); |
||||
|
x.insert(pair); |
||||
|
} |
||||
|
break; |
||||
|
|
||||
|
case MODE_WRITE: |
||||
|
case MODE_MEASURE: |
||||
|
case MODE_VERIFY: |
||||
|
for (auto itr = x.begin(); itr != x.end(); ++itr) |
||||
|
{ |
||||
|
Do(itr->first); |
||||
|
Do(itr->second); |
||||
|
} |
||||
|
break; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
template <typename T> |
||||
|
void DoContainer(T& x) |
||||
|
{ |
||||
|
u32 size = (u32)x.size(); |
||||
|
Do(size); |
||||
|
x.resize(size); |
||||
|
|
||||
|
for (auto itr = x.begin(); itr != x.end(); ++itr) |
||||
|
Do(*itr); |
||||
|
} |
||||
|
|
||||
|
template <typename T> |
||||
|
void Do(std::vector<T>& x) |
||||
|
{ |
||||
|
DoContainer(x); |
||||
|
} |
||||
|
|
||||
|
template <typename T> |
||||
|
void Do(std::list<T>& x) |
||||
|
{ |
||||
|
DoContainer(x); |
||||
|
} |
||||
|
|
||||
|
template <typename T> |
||||
|
void Do(std::deque<T>& x) |
||||
|
{ |
||||
|
DoContainer(x); |
||||
|
} |
||||
|
|
||||
|
template <typename T> |
||||
|
void Do(std::basic_string<T>& x) |
||||
|
{ |
||||
|
DoContainer(x); |
||||
|
} |
||||
|
|
||||
|
template <typename T> |
||||
|
void DoArray(T* x, u32 count) |
||||
|
{ |
||||
|
for (u32 i = 0; i != count; ++i) |
||||
|
Do(x[i]); |
||||
|
} |
||||
|
|
||||
|
template <typename T> |
||||
|
void Do(T& x) |
||||
|
{ |
||||
|
// Ideally this would be std::is_trivially_copyable, but not enough support yet |
||||
|
static_assert(std::is_pod<T>::value, "Only sane for POD types"); |
||||
|
|
||||
|
DoVoid((void*)&x, sizeof(x)); |
||||
|
} |
||||
|
|
||||
|
template <typename T> |
||||
|
void DoPOD(T& x) |
||||
|
{ |
||||
|
DoVoid((void*)&x, sizeof(x)); |
||||
|
} |
||||
|
|
||||
|
template <typename T> |
||||
|
void DoPointer(T*& x, T* const base) |
||||
|
{ |
||||
|
// pointers can be more than 2^31 apart, but you're using this function wrong if you need that much range |
||||
|
s32 offset = x - base; |
||||
|
Do(offset); |
||||
|
if (mode == MODE_READ) |
||||
|
x = base + offset; |
||||
|
} |
||||
|
|
||||
|
// Let's pretend std::list doesn't exist! |
||||
|
template <class T, LinkedListItem<T>* (*TNew)(), void (*TFree)(LinkedListItem<T>*), void (*TDo)(PointerWrap&, T*)> |
||||
|
void DoLinkedList(LinkedListItem<T>*& list_start, LinkedListItem<T>** list_end=0) |
||||
|
{ |
||||
|
LinkedListItem<T>* list_cur = list_start; |
||||
|
LinkedListItem<T>* prev = 0; |
||||
|
|
||||
|
while (true) |
||||
|
{ |
||||
|
u8 shouldExist = (list_cur ? 1 : 0); |
||||
|
Do(shouldExist); |
||||
|
if (shouldExist == 1) |
||||
|
{ |
||||
|
LinkedListItem<T>* cur = list_cur ? list_cur : TNew(); |
||||
|
TDo(*this, (T*)cur); |
||||
|
if (!list_cur) |
||||
|
{ |
||||
|
if (mode == MODE_READ) |
||||
|
{ |
||||
|
cur->next = 0; |
||||
|
list_cur = cur; |
||||
|
if (prev) |
||||
|
prev->next = cur; |
||||
|
else |
||||
|
list_start = cur; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
TFree(cur); |
||||
|
continue; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
if (mode == MODE_READ) |
||||
|
{ |
||||
|
if (prev) |
||||
|
prev->next = 0; |
||||
|
if (list_end) |
||||
|
*list_end = prev; |
||||
|
if (list_cur) |
||||
|
{ |
||||
|
if (list_start == list_cur) |
||||
|
list_start = 0; |
||||
|
do |
||||
|
{ |
||||
|
LinkedListItem<T>* next = list_cur->next; |
||||
|
TFree(list_cur); |
||||
|
list_cur = next; |
||||
|
} |
||||
|
while (list_cur); |
||||
|
} |
||||
|
} |
||||
|
break; |
||||
|
} |
||||
|
prev = list_cur; |
||||
|
list_cur = list_cur->next; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
void DoMarker(const char* prevName, u32 arbitraryNumber = 0x42) |
||||
|
{ |
||||
|
u32 cookie = arbitraryNumber; |
||||
|
Do(cookie); |
||||
|
|
||||
|
if (mode == PointerWrap::MODE_READ && cookie != arbitraryNumber) |
||||
|
{ |
||||
|
PanicAlertT("Error: After \"%s\", found %d (0x%X) instead of save marker %d (0x%X). Aborting savestate load...", |
||||
|
prevName, cookie, cookie, arbitraryNumber, arbitraryNumber); |
||||
|
mode = PointerWrap::MODE_MEASURE; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private: |
||||
|
__forceinline void DoByte(u8& x) |
||||
|
{ |
||||
|
switch (mode) |
||||
|
{ |
||||
|
case MODE_READ: |
||||
|
x = **ptr; |
||||
|
break; |
||||
|
|
||||
|
case MODE_WRITE: |
||||
|
**ptr = x; |
||||
|
break; |
||||
|
|
||||
|
case MODE_MEASURE: |
||||
|
break; |
||||
|
|
||||
|
case MODE_VERIFY: |
||||
|
_dbg_assert_msg_(COMMON, (x == **ptr), |
||||
|
"Savestate verification failure: %d (0x%X) (at %p) != %d (0x%X) (at %p).\n", |
||||
|
x, x, &x, **ptr, **ptr, *ptr); |
||||
|
break; |
||||
|
|
||||
|
default: |
||||
|
break; |
||||
|
} |
||||
|
|
||||
|
++(*ptr); |
||||
|
} |
||||
|
|
||||
|
void DoVoid(void *data, u32 size) |
||||
|
{ |
||||
|
for(u32 i = 0; i != size; ++i) |
||||
|
DoByte(reinterpret_cast<u8*>(data)[i]); |
||||
|
} |
||||
|
}; |
||||
|
|
||||
|
class CChunkFileReader |
||||
|
{ |
||||
|
public: |
||||
|
// Load file template |
||||
|
template<class T> |
||||
|
static bool Load(const std::string& _rFilename, u32 _Revision, T& _class) |
||||
|
{ |
||||
|
INFO_LOG(COMMON, "ChunkReader: Loading %s" , _rFilename.c_str()); |
||||
|
|
||||
|
if (!File::Exists(_rFilename)) |
||||
|
return false; |
||||
|
|
||||
|
// Check file size |
||||
|
const u64 fileSize = File::GetSize(_rFilename); |
||||
|
static const u64 headerSize = sizeof(SChunkHeader); |
||||
|
if (fileSize < headerSize) |
||||
|
{ |
||||
|
ERROR_LOG(COMMON,"ChunkReader: File too small"); |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
File::IOFile pFile(_rFilename, "rb"); |
||||
|
if (!pFile) |
||||
|
{ |
||||
|
ERROR_LOG(COMMON,"ChunkReader: Can't open file for reading"); |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
// read the header |
||||
|
SChunkHeader header; |
||||
|
if (!pFile.ReadArray(&header, 1)) |
||||
|
{ |
||||
|
ERROR_LOG(COMMON,"ChunkReader: Bad header size"); |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
// Check revision |
||||
|
if (header.Revision != _Revision) |
||||
|
{ |
||||
|
ERROR_LOG(COMMON,"ChunkReader: Wrong file revision, got %d expected %d", |
||||
|
header.Revision, _Revision); |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
// get size |
||||
|
const u32 sz = (u32)(fileSize - headerSize); |
||||
|
if (header.ExpectedSize != sz) |
||||
|
{ |
||||
|
ERROR_LOG(COMMON,"ChunkReader: Bad file size, got %d expected %d", |
||||
|
sz, header.ExpectedSize); |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
// read the state |
||||
|
std::vector<u8> buffer(sz); |
||||
|
if (!pFile.ReadArray(&buffer[0], sz)) |
||||
|
{ |
||||
|
ERROR_LOG(COMMON,"ChunkReader: Error reading file"); |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
u8* ptr = &buffer[0]; |
||||
|
PointerWrap p(&ptr, PointerWrap::MODE_READ); |
||||
|
_class.DoState(p); |
||||
|
|
||||
|
INFO_LOG(COMMON, "ChunkReader: Done loading %s" , _rFilename.c_str()); |
||||
|
return true; |
||||
|
} |
||||
|
|
||||
|
// Save file template |
||||
|
template<class T> |
||||
|
static bool Save(const std::string& _rFilename, u32 _Revision, T& _class) |
||||
|
{ |
||||
|
INFO_LOG(COMMON, "ChunkReader: Writing %s" , _rFilename.c_str()); |
||||
|
File::IOFile pFile(_rFilename, "wb"); |
||||
|
if (!pFile) |
||||
|
{ |
||||
|
ERROR_LOG(COMMON,"ChunkReader: Error opening file for write"); |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
// Get data |
||||
|
u8 *ptr = 0; |
||||
|
PointerWrap p(&ptr, PointerWrap::MODE_MEASURE); |
||||
|
_class.DoState(p); |
||||
|
size_t const sz = (size_t)ptr; |
||||
|
std::vector<u8> buffer(sz); |
||||
|
ptr = &buffer[0]; |
||||
|
p.SetMode(PointerWrap::MODE_WRITE); |
||||
|
_class.DoState(p); |
||||
|
|
||||
|
// Create header |
||||
|
SChunkHeader header; |
||||
|
header.Revision = _Revision; |
||||
|
header.ExpectedSize = (u32)sz; |
||||
|
|
||||
|
// Write to file |
||||
|
if (!pFile.WriteArray(&header, 1)) |
||||
|
{ |
||||
|
ERROR_LOG(COMMON,"ChunkReader: Failed writing header"); |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
if (!pFile.WriteArray(&buffer[0], sz)) |
||||
|
{ |
||||
|
ERROR_LOG(COMMON,"ChunkReader: Failed writing data"); |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
INFO_LOG(COMMON,"ChunkReader: Done writing %s", _rFilename.c_str()); |
||||
|
return true; |
||||
|
} |
||||
|
|
||||
|
private: |
||||
|
struct SChunkHeader |
||||
|
{ |
||||
|
u32 Revision; |
||||
|
u32 ExpectedSize; |
||||
|
}; |
||||
|
}; |
||||
|
|
||||
|
#endif // _POINTERWRAP_H_ |
||||
@ -0,0 +1,164 @@ |
|||||
|
// Copyright 2013 Dolphin Emulator Project |
||||
|
// Licensed under GPLv2 |
||||
|
// Refer to the license.txt file included. |
||||
|
|
||||
|
#ifndef _COMMON_H_ |
||||
|
#define _COMMON_H_ |
||||
|
|
||||
|
// DO NOT EVER INCLUDE <windows.h> directly _or indirectly_ from this file |
||||
|
// since it slows down the build a lot. |
||||
|
|
||||
|
#include <stdlib.h> |
||||
|
#include <stdio.h> |
||||
|
#include <string.h> |
||||
|
|
||||
|
// SVN version number |
||||
|
extern const char *scm_rev_str; |
||||
|
extern const char *netplay_dolphin_ver; |
||||
|
|
||||
|
// Force enable logging in the right modes. For some reason, something had changed |
||||
|
// so that debugfast no longer logged. |
||||
|
#if defined(_DEBUG) || defined(DEBUGFAST) |
||||
|
#undef LOGGING |
||||
|
#define LOGGING 1 |
||||
|
#endif |
||||
|
|
||||
|
#define STACKALIGN |
||||
|
|
||||
|
#if __cplusplus >= 201103 || defined(_MSC_VER) || defined(__GXX_EXPERIMENTAL_CXX0X__) |
||||
|
#define HAVE_CXX11_SYNTAX 1 |
||||
|
#endif |
||||
|
|
||||
|
#if HAVE_CXX11_SYNTAX |
||||
|
// An inheritable class to disallow the copy constructor and operator= functions |
||||
|
class NonCopyable |
||||
|
{ |
||||
|
protected: |
||||
|
NonCopyable() {} |
||||
|
NonCopyable(const NonCopyable&&) {} |
||||
|
void operator=(const NonCopyable&&) {} |
||||
|
private: |
||||
|
NonCopyable(NonCopyable&); |
||||
|
NonCopyable& operator=(NonCopyable& other); |
||||
|
}; |
||||
|
#endif |
||||
|
|
||||
|
#include "log.h" |
||||
|
#include "common_types.h" |
||||
|
#include "msg_handler.h" |
||||
|
#include "common_funcs.h" |
||||
|
|
||||
|
#ifdef __APPLE__ |
||||
|
// The Darwin ABI requires that stack frames be aligned to 16-byte boundaries. |
||||
|
// This is only needed on i386 gcc - x86_64 already aligns to 16 bytes. |
||||
|
#if defined __i386__ && defined __GNUC__ |
||||
|
#undef STACKALIGN |
||||
|
#define STACKALIGN __attribute__((__force_align_arg_pointer__)) |
||||
|
#endif |
||||
|
|
||||
|
#elif defined _WIN32 |
||||
|
|
||||
|
// Check MSC ver |
||||
|
#if !defined _MSC_VER || _MSC_VER <= 1000 |
||||
|
#error needs at least version 1000 of MSC |
||||
|
#endif |
||||
|
|
||||
|
#define NOMINMAX |
||||
|
|
||||
|
// Memory leak checks |
||||
|
#define CHECK_HEAP_INTEGRITY() |
||||
|
|
||||
|
// Alignment |
||||
|
#define GC_ALIGNED16(x) __declspec(align(16)) x |
||||
|
#define GC_ALIGNED32(x) __declspec(align(32)) x |
||||
|
#define GC_ALIGNED64(x) __declspec(align(64)) x |
||||
|
#define GC_ALIGNED128(x) __declspec(align(128)) x |
||||
|
#define GC_ALIGNED16_DECL(x) __declspec(align(16)) x |
||||
|
#define GC_ALIGNED64_DECL(x) __declspec(align(64)) x |
||||
|
|
||||
|
// Since they are always around on windows |
||||
|
#define HAVE_WX 1 |
||||
|
#define HAVE_OPENAL 1 |
||||
|
|
||||
|
#define HAVE_PORTAUDIO 1 |
||||
|
|
||||
|
// Debug definitions |
||||
|
#if defined(_DEBUG) |
||||
|
#include <crtdbg.h> |
||||
|
#undef CHECK_HEAP_INTEGRITY |
||||
|
#define CHECK_HEAP_INTEGRITY() {if (!_CrtCheckMemory()) PanicAlert("memory corruption detected. see log.");} |
||||
|
// If you want to see how much a pain in the ass singletons are, for example: |
||||
|
// {614} normal block at 0x030C5310, 188 bytes long. |
||||
|
// Data: <Master Log > 4D 61 73 74 65 72 20 4C 6F 67 00 00 00 00 00 00 |
||||
|
struct CrtDebugBreak { CrtDebugBreak(int spot) { _CrtSetBreakAlloc(spot); } }; |
||||
|
//CrtDebugBreak breakAt(614); |
||||
|
#endif // end DEBUG/FAST |
||||
|
|
||||
|
#endif |
||||
|
|
||||
|
// Windows compatibility |
||||
|
#ifndef _WIN32 |
||||
|
#include <limits.h> |
||||
|
#define MAX_PATH PATH_MAX |
||||
|
#ifdef _LP64 |
||||
|
#define _M_X64 1 |
||||
|
#else |
||||
|
#define _M_IX86 1 |
||||
|
#endif |
||||
|
#define __forceinline inline __attribute__((always_inline)) |
||||
|
#define GC_ALIGNED16(x) __attribute__((aligned(16))) x |
||||
|
#define GC_ALIGNED32(x) __attribute__((aligned(32))) x |
||||
|
#define GC_ALIGNED64(x) __attribute__((aligned(64))) x |
||||
|
#define GC_ALIGNED128(x) __attribute__((aligned(128))) x |
||||
|
#define GC_ALIGNED16_DECL(x) __attribute__((aligned(16))) x |
||||
|
#define GC_ALIGNED64_DECL(x) __attribute__((aligned(64))) x |
||||
|
#endif |
||||
|
|
||||
|
#ifdef _MSC_VER |
||||
|
#define __strdup _strdup |
||||
|
#define __getcwd _getcwd |
||||
|
#define __chdir _chdir |
||||
|
#else |
||||
|
#define __strdup strdup |
||||
|
#define __getcwd getcwd |
||||
|
#define __chdir chdir |
||||
|
#endif |
||||
|
|
||||
|
// Dummy macro for marking translatable strings that can not be immediately translated. |
||||
|
// wxWidgets does not have a true dummy macro for this. |
||||
|
#define _trans(a) a |
||||
|
|
||||
|
#if defined _M_GENERIC |
||||
|
# define _M_SSE 0x0 |
||||
|
#elif defined __GNUC__ |
||||
|
# if defined __SSE4_2__ |
||||
|
# define _M_SSE 0x402 |
||||
|
# elif defined __SSE4_1__ |
||||
|
# define _M_SSE 0x401 |
||||
|
# elif defined __SSSE3__ |
||||
|
# define _M_SSE 0x301 |
||||
|
# elif defined __SSE3__ |
||||
|
# define _M_SSE 0x300 |
||||
|
# endif |
||||
|
#elif (_MSC_VER >= 1500) || __INTEL_COMPILER // Visual Studio 2008 |
||||
|
# define _M_SSE 0x402 |
||||
|
#endif |
||||
|
|
||||
|
// Host communication. |
||||
|
enum HOST_COMM |
||||
|
{ |
||||
|
// Begin at 10 in case there is already messages with wParam = 0, 1, 2 and so on |
||||
|
WM_USER_STOP = 10, |
||||
|
WM_USER_CREATE, |
||||
|
WM_USER_SETCURSOR, |
||||
|
}; |
||||
|
|
||||
|
// Used for notification on emulation state |
||||
|
enum EMUSTATE_CHANGE |
||||
|
{ |
||||
|
EMUSTATE_CHANGE_PLAY = 1, |
||||
|
EMUSTATE_CHANGE_PAUSE, |
||||
|
EMUSTATE_CHANGE_STOP |
||||
|
}; |
||||
|
|
||||
|
#endif // _COMMON_H_ |
||||
@ -0,0 +1,243 @@ |
|||||
|
// Copyright 2013 Dolphin Emulator Project |
||||
|
// Licensed under GPLv2 |
||||
|
// Refer to the license.txt file included. |
||||
|
|
||||
|
#ifndef _COMMONFUNCS_H_ |
||||
|
#define _COMMONFUNCS_H_ |
||||
|
|
||||
|
#ifdef _WIN32 |
||||
|
#define SLEEP(x) Sleep(x) |
||||
|
#else |
||||
|
#include <unistd.h> |
||||
|
#define SLEEP(x) usleep(x*1000) |
||||
|
#endif |
||||
|
|
||||
|
template <bool> struct CompileTimeAssert; |
||||
|
template<> struct CompileTimeAssert<true> {}; |
||||
|
|
||||
|
#define b2(x) ( (x) | ( (x) >> 1) ) |
||||
|
#define b4(x) ( b2(x) | ( b2(x) >> 2) ) |
||||
|
#define b8(x) ( b4(x) | ( b4(x) >> 4) ) |
||||
|
#define b16(x) ( b8(x) | ( b8(x) >> 8) ) |
||||
|
#define b32(x) (b16(x) | (b16(x) >>16) ) |
||||
|
#define ROUND_UP_POW2(x) (b32(x - 1) + 1) |
||||
|
|
||||
|
#if defined __GNUC__ && !defined __SSSE3__ && !defined _M_GENERIC |
||||
|
#include <emmintrin.h> |
||||
|
static __inline __m128i __attribute__((__always_inline__)) |
||||
|
_mm_shuffle_epi8(__m128i a, __m128i mask) |
||||
|
{ |
||||
|
__m128i result; |
||||
|
__asm__("pshufb %1, %0" |
||||
|
: "=x" (result) |
||||
|
: "xm" (mask), "0" (a)); |
||||
|
return result; |
||||
|
} |
||||
|
#endif |
||||
|
|
||||
|
#ifndef _WIN32 |
||||
|
|
||||
|
#include <errno.h> |
||||
|
#ifdef __linux__ |
||||
|
#include <byteswap.h> |
||||
|
#elif defined __FreeBSD__ |
||||
|
#include <sys/endian.h> |
||||
|
#endif |
||||
|
|
||||
|
// go to debugger mode |
||||
|
#ifdef GEKKO |
||||
|
#define Crash() |
||||
|
#elif defined _M_GENERIC |
||||
|
#define Crash() { exit(1); } |
||||
|
#else |
||||
|
#define Crash() {asm ("int $3");} |
||||
|
#endif |
||||
|
#define ARRAYSIZE(A) (sizeof(A)/sizeof((A)[0])) |
||||
|
// GCC 4.8 defines all the rotate functions now |
||||
|
// Small issue with GCC's lrotl/lrotr intrinsics is they are still 32bit while we require 64bit |
||||
|
#ifndef _rotl |
||||
|
inline u32 _rotl(u32 x, int shift) { |
||||
|
shift &= 31; |
||||
|
if (!shift) return x; |
||||
|
return (x << shift) | (x >> (32 - shift)); |
||||
|
} |
||||
|
|
||||
|
inline u32 _rotr(u32 x, int shift) { |
||||
|
shift &= 31; |
||||
|
if (!shift) return x; |
||||
|
return (x >> shift) | (x << (32 - shift)); |
||||
|
} |
||||
|
#endif |
||||
|
|
||||
|
inline u64 _rotl64(u64 x, unsigned int shift){ |
||||
|
unsigned int n = shift % 64; |
||||
|
return (x << n) | (x >> (64 - n)); |
||||
|
} |
||||
|
|
||||
|
inline u64 _rotr64(u64 x, unsigned int shift){ |
||||
|
unsigned int n = shift % 64; |
||||
|
return (x >> n) | (x << (64 - n)); |
||||
|
} |
||||
|
|
||||
|
#else // WIN32 |
||||
|
// Function Cross-Compatibility |
||||
|
#define strcasecmp _stricmp |
||||
|
#define strncasecmp _strnicmp |
||||
|
#define unlink _unlink |
||||
|
#define snprintf _snprintf |
||||
|
#define vscprintf _vscprintf |
||||
|
|
||||
|
// Locale Cross-Compatibility |
||||
|
#define locale_t _locale_t |
||||
|
#define freelocale _free_locale |
||||
|
#define newlocale(mask, locale, base) _create_locale(mask, locale) |
||||
|
|
||||
|
#define LC_GLOBAL_LOCALE ((locale_t)-1) |
||||
|
#define LC_ALL_MASK LC_ALL |
||||
|
#define LC_COLLATE_MASK LC_COLLATE |
||||
|
#define LC_CTYPE_MASK LC_CTYPE |
||||
|
#define LC_MONETARY_MASK LC_MONETARY |
||||
|
#define LC_NUMERIC_MASK LC_NUMERIC |
||||
|
#define LC_TIME_MASK LC_TIME |
||||
|
|
||||
|
inline locale_t uselocale(locale_t new_locale) |
||||
|
{ |
||||
|
// Retrieve the current per thread locale setting |
||||
|
bool bIsPerThread = (_configthreadlocale(0) == _ENABLE_PER_THREAD_LOCALE); |
||||
|
|
||||
|
// Retrieve the current thread-specific locale |
||||
|
locale_t old_locale = bIsPerThread ? _get_current_locale() : LC_GLOBAL_LOCALE; |
||||
|
|
||||
|
if(new_locale == LC_GLOBAL_LOCALE) |
||||
|
{ |
||||
|
// Restore the global locale |
||||
|
_configthreadlocale(_DISABLE_PER_THREAD_LOCALE); |
||||
|
} |
||||
|
else if(new_locale != NULL) |
||||
|
{ |
||||
|
// Configure the thread to set the locale only for this thread |
||||
|
_configthreadlocale(_ENABLE_PER_THREAD_LOCALE); |
||||
|
|
||||
|
// Set all locale categories |
||||
|
for(int i = LC_MIN; i <= LC_MAX; i++) |
||||
|
setlocale(i, new_locale->locinfo->lc_category[i].locale); |
||||
|
} |
||||
|
|
||||
|
return old_locale; |
||||
|
} |
||||
|
|
||||
|
// 64 bit offsets for windows |
||||
|
#define fseeko _fseeki64 |
||||
|
#define ftello _ftelli64 |
||||
|
#define atoll _atoi64 |
||||
|
#define stat64 _stat64 |
||||
|
#define fstat64 _fstat64 |
||||
|
#define fileno _fileno |
||||
|
|
||||
|
#if _M_IX86 |
||||
|
#define Crash() {__asm int 3} |
||||
|
#else |
||||
|
extern "C" { |
||||
|
__declspec(dllimport) void __stdcall DebugBreak(void); |
||||
|
} |
||||
|
#define Crash() {DebugBreak();} |
||||
|
#endif // M_IX86 |
||||
|
#endif // WIN32 ndef |
||||
|
|
||||
|
// Dolphin's min and max functions |
||||
|
#undef min |
||||
|
#undef max |
||||
|
|
||||
|
template<class T> |
||||
|
inline T min(const T& a, const T& b) {return a > b ? b : a;} |
||||
|
template<class T> |
||||
|
inline T max(const T& a, const T& b) {return a > b ? a : b;} |
||||
|
|
||||
|
// Generic function to get last error message. |
||||
|
// Call directly after the command or use the error num. |
||||
|
// This function might change the error code. |
||||
|
// Defined in Misc.cpp. |
||||
|
const char* GetLastErrorMsg(); |
||||
|
|
||||
|
namespace Common |
||||
|
{ |
||||
|
inline u8 swap8(u8 _data) {return _data;} |
||||
|
inline u32 swap24(const u8* _data) {return (_data[0] << 16) | (_data[1] << 8) | _data[2];} |
||||
|
|
||||
|
#ifdef ANDROID |
||||
|
#undef swap16 |
||||
|
#undef swap32 |
||||
|
#undef swap64 |
||||
|
#endif |
||||
|
|
||||
|
#ifdef _WIN32 |
||||
|
inline u16 swap16(u16 _data) {return _byteswap_ushort(_data);} |
||||
|
inline u32 swap32(u32 _data) {return _byteswap_ulong (_data);} |
||||
|
inline u64 swap64(u64 _data) {return _byteswap_uint64(_data);} |
||||
|
#elif _M_ARM |
||||
|
inline u16 swap16 (u16 _data) { u32 data = _data; __asm__ ("rev16 %0, %1\n" : "=l" (data) : "l" (data)); return (u16)data;} |
||||
|
inline u32 swap32 (u32 _data) {__asm__ ("rev %0, %1\n" : "=l" (_data) : "l" (_data)); return _data;} |
||||
|
inline u64 swap64(u64 _data) {return ((u64)swap32(_data) << 32) | swap32(_data >> 32);} |
||||
|
#elif __linux__ |
||||
|
inline u16 swap16(u16 _data) {return bswap_16(_data);} |
||||
|
inline u32 swap32(u32 _data) {return bswap_32(_data);} |
||||
|
inline u64 swap64(u64 _data) {return bswap_64(_data);} |
||||
|
#elif __APPLE__ |
||||
|
inline __attribute__((always_inline)) u16 swap16(u16 _data) |
||||
|
{return (_data >> 8) | (_data << 8);} |
||||
|
inline __attribute__((always_inline)) u32 swap32(u32 _data) |
||||
|
{return __builtin_bswap32(_data);} |
||||
|
inline __attribute__((always_inline)) u64 swap64(u64 _data) |
||||
|
{return __builtin_bswap64(_data);} |
||||
|
#elif __FreeBSD__ |
||||
|
inline u16 swap16(u16 _data) {return bswap16(_data);} |
||||
|
inline u32 swap32(u32 _data) {return bswap32(_data);} |
||||
|
inline u64 swap64(u64 _data) {return bswap64(_data);} |
||||
|
#else |
||||
|
// Slow generic implementation. |
||||
|
inline u16 swap16(u16 data) {return (data >> 8) | (data << 8);} |
||||
|
inline u32 swap32(u32 data) {return (swap16(data) << 16) | swap16(data >> 16);} |
||||
|
inline u64 swap64(u64 data) {return ((u64)swap32(data) << 32) | swap32(data >> 32);} |
||||
|
#endif |
||||
|
|
||||
|
inline u16 swap16(const u8* _pData) {return swap16(*(const u16*)_pData);} |
||||
|
inline u32 swap32(const u8* _pData) {return swap32(*(const u32*)_pData);} |
||||
|
inline u64 swap64(const u8* _pData) {return swap64(*(const u64*)_pData);} |
||||
|
|
||||
|
template <int count> |
||||
|
void swap(u8*); |
||||
|
|
||||
|
template <> |
||||
|
inline void swap<1>(u8* data) |
||||
|
{} |
||||
|
|
||||
|
template <> |
||||
|
inline void swap<2>(u8* data) |
||||
|
{ |
||||
|
*reinterpret_cast<u16*>(data) = swap16(data); |
||||
|
} |
||||
|
|
||||
|
template <> |
||||
|
inline void swap<4>(u8* data) |
||||
|
{ |
||||
|
*reinterpret_cast<u32*>(data) = swap32(data); |
||||
|
} |
||||
|
|
||||
|
template <> |
||||
|
inline void swap<8>(u8* data) |
||||
|
{ |
||||
|
*reinterpret_cast<u64*>(data) = swap64(data); |
||||
|
} |
||||
|
|
||||
|
template <typename T> |
||||
|
inline T FromBigEndian(T data) |
||||
|
{ |
||||
|
//static_assert(std::is_arithmetic<T>::value, "function only makes sense with arithmetic types"); |
||||
|
|
||||
|
swap<sizeof(data)>(reinterpret_cast<u8*>(&data)); |
||||
|
return data; |
||||
|
} |
||||
|
|
||||
|
} // Namespace Common |
||||
|
|
||||
|
#endif // _COMMONFUNCS_H_ |
||||
@ -0,0 +1,71 @@ |
|||||
|
// Copyright 2013 Dolphin Emulator Project |
||||
|
// Licensed under GPLv2 |
||||
|
// Refer to the license.txt file included. |
||||
|
|
||||
|
#ifndef _COMMON_PATHS_H_ |
||||
|
#define _COMMON_PATHS_H_ |
||||
|
|
||||
|
// Make sure we pick up USER_DIR if set in config.h |
||||
|
#include "common.h" |
||||
|
|
||||
|
// Directory seperators, do we need this? |
||||
|
#define DIR_SEP "/" |
||||
|
#define DIR_SEP_CHR '/' |
||||
|
|
||||
|
// The user data dir |
||||
|
#define ROOT_DIR "." |
||||
|
#ifdef _WIN32 |
||||
|
#define USERDATA_DIR "user" |
||||
|
#define DOLPHIN_DATA_DIR "akiru" |
||||
|
#else |
||||
|
#define USERDATA_DIR "user" |
||||
|
#ifdef USER_DIR |
||||
|
#define DOLPHIN_DATA_DIR USER_DIR |
||||
|
#else |
||||
|
#define DOLPHIN_DATA_DIR ".akiru" |
||||
|
#endif |
||||
|
#endif |
||||
|
|
||||
|
// Shared data dirs (Sys and shared User for linux) |
||||
|
#ifdef _WIN32 |
||||
|
#define SYSDATA_DIR "sys" |
||||
|
#else |
||||
|
#ifdef DATA_DIR |
||||
|
#define SYSDATA_DIR DATA_DIR "sys" |
||||
|
#define SHARED_USER_DIR DATA_DIR USERDATA_DIR DIR_SEP |
||||
|
#else |
||||
|
#define SYSDATA_DIR "sys" |
||||
|
#define SHARED_USER_DIR ROOT_DIR DIR_SEP USERDATA_DIR DIR_SEP |
||||
|
#endif |
||||
|
#endif |
||||
|
|
||||
|
// Dirs in both User and Sys |
||||
|
#define EUR_DIR "EUR" |
||||
|
#define USA_DIR "USA" |
||||
|
#define JAP_DIR "JAP" |
||||
|
|
||||
|
// Subdirs in the User dir returned by GetUserPath(D_USER_IDX) |
||||
|
#define CONFIG_DIR "config" |
||||
|
#define GAMECONFIG_DIR "game_config" |
||||
|
#define MAPS_DIR "maps" |
||||
|
#define CACHE_DIR "cache" |
||||
|
#define SHADERCACHE_DIR "shader_cache" |
||||
|
#define STATESAVES_DIR "state_saves" |
||||
|
#define SCREENSHOTS_DIR "screenShots" |
||||
|
#define DUMP_DIR "dump" |
||||
|
#define DUMP_TEXTURES_DIR "textures" |
||||
|
#define DUMP_FRAMES_DIR "frames" |
||||
|
#define DUMP_AUDIO_DIR "audio" |
||||
|
#define LOGS_DIR "logs" |
||||
|
#define SHADERS_DIR "shaders" |
||||
|
|
||||
|
// Filenames |
||||
|
// Files in the directory returned by GetUserPath(D_CONFIG_IDX) |
||||
|
#define AKIRU_CONFIG "akiru.ini" |
||||
|
#define DEBUGGER_CONFIG "debugger.ini" |
||||
|
#define LOGGER_CONFIG "logger.ini" |
||||
|
|
||||
|
// Files in the directory returned by GetUserPath(D_LOGS_IDX) |
||||
|
#define MAIN_LOG "akiru.log" |
||||
|
|
||||
|
#endif // _COMMON_PATHS_H_ |
||||
@ -0,0 +1,48 @@ |
|||||
|
// Copyright 2013 Dolphin Emulator Project |
||||
|
// Licensed under GPLv2 |
||||
|
// Refer to the license.txt file included. |
||||
|
|
||||
|
|
||||
|
// This header contains type definitions that are shared between the Dolphin core and |
||||
|
// other parts of the code. Any definitions that are only used by the core should be |
||||
|
// placed in "common.h" instead. |
||||
|
|
||||
|
#ifndef _COMMONTYPES_H_ |
||||
|
#define _COMMONTYPES_H_ |
||||
|
|
||||
|
#ifdef _WIN32 |
||||
|
|
||||
|
#include <tchar.h> |
||||
|
|
||||
|
typedef unsigned __int8 u8; |
||||
|
typedef unsigned __int16 u16; |
||||
|
typedef unsigned __int32 u32; |
||||
|
typedef unsigned __int64 u64; |
||||
|
|
||||
|
typedef signed __int8 s8; |
||||
|
typedef signed __int16 s16; |
||||
|
typedef signed __int32 s32; |
||||
|
typedef signed __int64 s64; |
||||
|
|
||||
|
#else |
||||
|
|
||||
|
#ifndef GEKKO |
||||
|
|
||||
|
typedef unsigned char u8; |
||||
|
typedef unsigned short u16; |
||||
|
typedef unsigned int u32; |
||||
|
typedef unsigned long long u64; |
||||
|
|
||||
|
typedef signed char s8; |
||||
|
typedef signed short s16; |
||||
|
typedef signed int s32; |
||||
|
typedef signed long long s64; |
||||
|
|
||||
|
#endif |
||||
|
// For using windows lock code |
||||
|
#define TCHAR char |
||||
|
#define LONG int |
||||
|
|
||||
|
#endif // _WIN32 |
||||
|
|
||||
|
#endif // _COMMONTYPES_H_ |
||||
@ -0,0 +1,337 @@ |
|||||
|
// Copyright 2013 Dolphin Emulator Project
|
||||
|
// Licensed under GPLv2
|
||||
|
// Refer to the license.txt file included.
|
||||
|
|
||||
|
#include <algorithm> // min
|
||||
|
#include <string> // System: To be able to add strings with "+"
|
||||
|
#include <stdio.h>
|
||||
|
#include <math.h>
|
||||
|
#ifdef _WIN32
|
||||
|
#include <windows.h>
|
||||
|
#include <array>
|
||||
|
#else
|
||||
|
#include <stdarg.h>
|
||||
|
#endif
|
||||
|
|
||||
|
#include "common.h"
|
||||
|
#include "log_manager.h" // Common
|
||||
|
#include "console_listener.h" // Common
|
||||
|
|
||||
|
ConsoleListener::ConsoleListener() |
||||
|
{ |
||||
|
#ifdef _WIN32
|
||||
|
hConsole = NULL; |
||||
|
bUseColor = true; |
||||
|
#else
|
||||
|
bUseColor = isatty(fileno(stdout)); |
||||
|
#endif
|
||||
|
} |
||||
|
|
||||
|
ConsoleListener::~ConsoleListener() |
||||
|
{ |
||||
|
Close(); |
||||
|
} |
||||
|
|
||||
|
// 100, 100, "Dolphin Log Console"
|
||||
|
// Open console window - width and height is the size of console window
|
||||
|
// Name is the window title
|
||||
|
void ConsoleListener::Open(bool Hidden, int Width, int Height, const char *Title) |
||||
|
{ |
||||
|
#ifdef _WIN32
|
||||
|
if (!GetConsoleWindow()) |
||||
|
{ |
||||
|
// Open the console window and create the window handle for GetStdHandle()
|
||||
|
AllocConsole(); |
||||
|
// Hide
|
||||
|
if (Hidden) ShowWindow(GetConsoleWindow(), SW_HIDE); |
||||
|
// Save the window handle that AllocConsole() created
|
||||
|
hConsole = GetStdHandle(STD_OUTPUT_HANDLE); |
||||
|
// Set the console window title
|
||||
|
SetConsoleTitle(UTF8ToTStr(Title).c_str()); |
||||
|
// Set letter space
|
||||
|
LetterSpace(80, 4000); |
||||
|
//MoveWindow(GetConsoleWindow(), 200,200, 800,800, true);
|
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
hConsole = GetStdHandle(STD_OUTPUT_HANDLE); |
||||
|
} |
||||
|
#endif
|
||||
|
} |
||||
|
|
||||
|
void ConsoleListener::UpdateHandle() |
||||
|
{ |
||||
|
#ifdef _WIN32
|
||||
|
hConsole = GetStdHandle(STD_OUTPUT_HANDLE); |
||||
|
#endif
|
||||
|
} |
||||
|
|
||||
|
// Close the console window and close the eventual file handle
|
||||
|
void ConsoleListener::Close() |
||||
|
{ |
||||
|
#ifdef _WIN32
|
||||
|
if (hConsole == NULL) |
||||
|
return; |
||||
|
FreeConsole(); |
||||
|
hConsole = NULL; |
||||
|
#else
|
||||
|
fflush(NULL); |
||||
|
#endif
|
||||
|
} |
||||
|
|
||||
|
bool ConsoleListener::IsOpen() |
||||
|
{ |
||||
|
#ifdef _WIN32
|
||||
|
return (hConsole != NULL); |
||||
|
#else
|
||||
|
return true; |
||||
|
#endif
|
||||
|
} |
||||
|
|
||||
|
/*
|
||||
|
LetterSpace: SetConsoleScreenBufferSize and SetConsoleWindowInfo are |
||||
|
dependent on each other, that's the reason for the additional checks. |
||||
|
*/ |
||||
|
void ConsoleListener::BufferWidthHeight(int BufferWidth, int BufferHeight, int ScreenWidth, int ScreenHeight, bool BufferFirst) |
||||
|
{ |
||||
|
#ifdef _WIN32
|
||||
|
BOOL SB, SW; |
||||
|
if (BufferFirst) |
||||
|
{ |
||||
|
// Change screen buffer size
|
||||
|
COORD Co = {BufferWidth, BufferHeight}; |
||||
|
SB = SetConsoleScreenBufferSize(hConsole, Co); |
||||
|
// Change the screen buffer window size
|
||||
|
SMALL_RECT coo = {0,0,ScreenWidth, ScreenHeight}; // top, left, right, bottom
|
||||
|
SW = SetConsoleWindowInfo(hConsole, TRUE, &coo); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
// Change the screen buffer window size
|
||||
|
SMALL_RECT coo = {0,0, ScreenWidth, ScreenHeight}; // top, left, right, bottom
|
||||
|
SW = SetConsoleWindowInfo(hConsole, TRUE, &coo); |
||||
|
// Change screen buffer size
|
||||
|
COORD Co = {BufferWidth, BufferHeight}; |
||||
|
SB = SetConsoleScreenBufferSize(hConsole, Co); |
||||
|
} |
||||
|
#endif
|
||||
|
} |
||||
|
void ConsoleListener::LetterSpace(int Width, int Height) |
||||
|
{ |
||||
|
#ifdef _WIN32
|
||||
|
// Get console info
|
||||
|
CONSOLE_SCREEN_BUFFER_INFO ConInfo; |
||||
|
GetConsoleScreenBufferInfo(hConsole, &ConInfo); |
||||
|
|
||||
|
//
|
||||
|
int OldBufferWidth = ConInfo.dwSize.X; |
||||
|
int OldBufferHeight = ConInfo.dwSize.Y; |
||||
|
int OldScreenWidth = (ConInfo.srWindow.Right - ConInfo.srWindow.Left); |
||||
|
int OldScreenHeight = (ConInfo.srWindow.Bottom - ConInfo.srWindow.Top); |
||||
|
//
|
||||
|
int NewBufferWidth = Width; |
||||
|
int NewBufferHeight = Height; |
||||
|
int NewScreenWidth = NewBufferWidth - 1; |
||||
|
int NewScreenHeight = OldScreenHeight; |
||||
|
|
||||
|
// Width
|
||||
|
BufferWidthHeight(NewBufferWidth, OldBufferHeight, NewScreenWidth, OldScreenHeight, (NewBufferWidth > OldScreenWidth-1)); |
||||
|
// Height
|
||||
|
BufferWidthHeight(NewBufferWidth, NewBufferHeight, NewScreenWidth, NewScreenHeight, (NewBufferHeight > OldScreenHeight-1)); |
||||
|
|
||||
|
// Resize the window too
|
||||
|
//MoveWindow(GetConsoleWindow(), 200,200, (Width*8 + 50),(NewScreenHeight*12 + 200), true);
|
||||
|
#endif
|
||||
|
} |
||||
|
#ifdef _WIN32
|
||||
|
COORD ConsoleListener::GetCoordinates(int BytesRead, int BufferWidth) |
||||
|
{ |
||||
|
COORD Ret = {0, 0}; |
||||
|
// Full rows
|
||||
|
int Step = (int)floor((float)BytesRead / (float)BufferWidth); |
||||
|
Ret.Y += Step; |
||||
|
// Partial row
|
||||
|
Ret.X = BytesRead - (BufferWidth * Step); |
||||
|
return Ret; |
||||
|
} |
||||
|
#endif
|
||||
|
void ConsoleListener::PixelSpace(int Left, int Top, int Width, int Height, bool Resize) |
||||
|
{ |
||||
|
#ifdef _WIN32
|
||||
|
// Check size
|
||||
|
if (Width < 8 || Height < 12) return; |
||||
|
|
||||
|
bool DBef = true; |
||||
|
bool DAft = true; |
||||
|
std::string SLog = ""; |
||||
|
|
||||
|
const HWND hWnd = GetConsoleWindow(); |
||||
|
const HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE); |
||||
|
|
||||
|
// Get console info
|
||||
|
CONSOLE_SCREEN_BUFFER_INFO ConInfo; |
||||
|
GetConsoleScreenBufferInfo(hConsole, &ConInfo); |
||||
|
DWORD BufferSize = ConInfo.dwSize.X * ConInfo.dwSize.Y; |
||||
|
|
||||
|
// ---------------------------------------------------------------------
|
||||
|
// Save the current text
|
||||
|
// ------------------------
|
||||
|
DWORD cCharsRead = 0; |
||||
|
COORD coordScreen = { 0, 0 }; |
||||
|
|
||||
|
static const int MAX_BYTES = 1024 * 16; |
||||
|
|
||||
|
std::vector<std::array<TCHAR, MAX_BYTES>> Str; |
||||
|
std::vector<std::array<WORD, MAX_BYTES>> Attr; |
||||
|
|
||||
|
// ReadConsoleOutputAttribute seems to have a limit at this level
|
||||
|
static const int ReadBufferSize = MAX_BYTES - 32; |
||||
|
|
||||
|
DWORD cAttrRead = ReadBufferSize; |
||||
|
DWORD BytesRead = 0; |
||||
|
while (BytesRead < BufferSize) |
||||
|
{ |
||||
|
Str.resize(Str.size() + 1); |
||||
|
if (!ReadConsoleOutputCharacter(hConsole, Str.back().data(), ReadBufferSize, coordScreen, &cCharsRead)) |
||||
|
SLog += StringFromFormat("WriteConsoleOutputCharacter error"); |
||||
|
|
||||
|
Attr.resize(Attr.size() + 1); |
||||
|
if (!ReadConsoleOutputAttribute(hConsole, Attr.back().data(), ReadBufferSize, coordScreen, &cAttrRead)) |
||||
|
SLog += StringFromFormat("WriteConsoleOutputAttribute error"); |
||||
|
|
||||
|
// Break on error
|
||||
|
if (cAttrRead == 0) break; |
||||
|
BytesRead += cAttrRead; |
||||
|
coordScreen = GetCoordinates(BytesRead, ConInfo.dwSize.X); |
||||
|
} |
||||
|
// Letter space
|
||||
|
int LWidth = (int)(floor((float)Width / 8.0f) - 1.0f); |
||||
|
int LHeight = (int)(floor((float)Height / 12.0f) - 1.0f); |
||||
|
int LBufWidth = LWidth + 1; |
||||
|
int LBufHeight = (int)floor((float)BufferSize / (float)LBufWidth); |
||||
|
// Change screen buffer size
|
||||
|
LetterSpace(LBufWidth, LBufHeight); |
||||
|
|
||||
|
|
||||
|
ClearScreen(true); |
||||
|
coordScreen.Y = 0; |
||||
|
coordScreen.X = 0; |
||||
|
DWORD cCharsWritten = 0; |
||||
|
|
||||
|
int BytesWritten = 0; |
||||
|
DWORD cAttrWritten = 0; |
||||
|
for (size_t i = 0; i < Attr.size(); i++) |
||||
|
{ |
||||
|
if (!WriteConsoleOutputCharacter(hConsole, Str[i].data(), ReadBufferSize, coordScreen, &cCharsWritten)) |
||||
|
SLog += StringFromFormat("WriteConsoleOutputCharacter error"); |
||||
|
if (!WriteConsoleOutputAttribute(hConsole, Attr[i].data(), ReadBufferSize, coordScreen, &cAttrWritten)) |
||||
|
SLog += StringFromFormat("WriteConsoleOutputAttribute error"); |
||||
|
|
||||
|
BytesWritten += cAttrWritten; |
||||
|
coordScreen = GetCoordinates(BytesWritten, LBufWidth); |
||||
|
} |
||||
|
|
||||
|
const int OldCursor = ConInfo.dwCursorPosition.Y * ConInfo.dwSize.X + ConInfo.dwCursorPosition.X; |
||||
|
COORD Coo = GetCoordinates(OldCursor, LBufWidth); |
||||
|
SetConsoleCursorPosition(hConsole, Coo); |
||||
|
|
||||
|
if (SLog.length() > 0) Log(LogTypes::LNOTICE, SLog.c_str()); |
||||
|
|
||||
|
// Resize the window too
|
||||
|
if (Resize) MoveWindow(GetConsoleWindow(), Left,Top, (Width + 100),Height, true); |
||||
|
#endif
|
||||
|
} |
||||
|
|
||||
|
void ConsoleListener::Log(LogTypes::LOG_LEVELS Level, const char *Text) |
||||
|
{ |
||||
|
#if defined(_WIN32)
|
||||
|
/*
|
||||
|
const int MAX_BYTES = 1024*10; |
||||
|
char Str[MAX_BYTES]; |
||||
|
va_list ArgPtr; |
||||
|
int Cnt; |
||||
|
va_start(ArgPtr, Text); |
||||
|
Cnt = vsnprintf(Str, MAX_BYTES, Text, ArgPtr); |
||||
|
va_end(ArgPtr); |
||||
|
*/ |
||||
|
DWORD cCharsWritten; |
||||
|
WORD Color; |
||||
|
|
||||
|
switch (Level) |
||||
|
{ |
||||
|
case NOTICE_LEVEL: // light green
|
||||
|
Color = FOREGROUND_GREEN | FOREGROUND_INTENSITY; |
||||
|
break; |
||||
|
case ERROR_LEVEL: // light red
|
||||
|
Color = FOREGROUND_RED | FOREGROUND_INTENSITY; |
||||
|
break; |
||||
|
case WARNING_LEVEL: // light yellow
|
||||
|
Color = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY; |
||||
|
break; |
||||
|
case INFO_LEVEL: // cyan
|
||||
|
Color = FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY; |
||||
|
break; |
||||
|
case DEBUG_LEVEL: // gray
|
||||
|
Color = FOREGROUND_INTENSITY; |
||||
|
break; |
||||
|
default: // off-white
|
||||
|
Color = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; |
||||
|
break; |
||||
|
} |
||||
|
if (strlen(Text) > 10) |
||||
|
{ |
||||
|
// First 10 chars white
|
||||
|
SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY); |
||||
|
WriteConsole(hConsole, Text, 10, &cCharsWritten, NULL); |
||||
|
Text += 10; |
||||
|
} |
||||
|
SetConsoleTextAttribute(hConsole, Color); |
||||
|
WriteConsole(hConsole, Text, (DWORD)strlen(Text), &cCharsWritten, NULL); |
||||
|
#else
|
||||
|
char ColorAttr[16] = ""; |
||||
|
char ResetAttr[16] = ""; |
||||
|
|
||||
|
if (bUseColor) |
||||
|
{ |
||||
|
strcpy(ResetAttr, "\033[0m"); |
||||
|
switch (Level) |
||||
|
{ |
||||
|
case NOTICE_LEVEL: // light green
|
||||
|
strcpy(ColorAttr, "\033[92m"); |
||||
|
break; |
||||
|
case ERROR_LEVEL: // light red
|
||||
|
strcpy(ColorAttr, "\033[91m"); |
||||
|
break; |
||||
|
case WARNING_LEVEL: // light yellow
|
||||
|
strcpy(ColorAttr, "\033[93m"); |
||||
|
break; |
||||
|
default: |
||||
|
break; |
||||
|
} |
||||
|
} |
||||
|
fprintf(stderr, "%s%s%s", ColorAttr, Text, ResetAttr); |
||||
|
#endif
|
||||
|
} |
||||
|
// Clear console screen
|
||||
|
void ConsoleListener::ClearScreen(bool Cursor) |
||||
|
{ |
||||
|
#if defined(_WIN32)
|
||||
|
COORD coordScreen = { 0, 0 }; |
||||
|
DWORD cCharsWritten; |
||||
|
CONSOLE_SCREEN_BUFFER_INFO csbi; |
||||
|
DWORD dwConSize; |
||||
|
|
||||
|
HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE); |
||||
|
|
||||
|
GetConsoleScreenBufferInfo(hConsole, &csbi); |
||||
|
dwConSize = csbi.dwSize.X * csbi.dwSize.Y; |
||||
|
// Write space to the entire console
|
||||
|
FillConsoleOutputCharacter(hConsole, TEXT(' '), dwConSize, coordScreen, &cCharsWritten); |
||||
|
GetConsoleScreenBufferInfo(hConsole, &csbi); |
||||
|
FillConsoleOutputAttribute(hConsole, csbi.wAttributes, dwConSize, coordScreen, &cCharsWritten); |
||||
|
// Reset cursor
|
||||
|
if (Cursor) SetConsoleCursorPosition(hConsole, coordScreen); |
||||
|
#endif
|
||||
|
} |
||||
|
|
||||
|
|
||||
@ -0,0 +1,41 @@ |
|||||
|
// Copyright 2013 Dolphin Emulator Project |
||||
|
// Licensed under GPLv2 |
||||
|
// Refer to the license.txt file included. |
||||
|
|
||||
|
#ifndef _CONSOLELISTENER_H |
||||
|
#define _CONSOLELISTENER_H |
||||
|
|
||||
|
#include "log_manager.h" |
||||
|
|
||||
|
#ifdef _WIN32 |
||||
|
#include <windows.h> |
||||
|
#endif |
||||
|
|
||||
|
class ConsoleListener : public LogListener |
||||
|
{ |
||||
|
public: |
||||
|
ConsoleListener(); |
||||
|
~ConsoleListener(); |
||||
|
|
||||
|
void Open(bool Hidden = false, int Width = 100, int Height = 100, const char * Name = "Console"); |
||||
|
void UpdateHandle(); |
||||
|
void Close(); |
||||
|
bool IsOpen(); |
||||
|
void LetterSpace(int Width, int Height); |
||||
|
void BufferWidthHeight(int BufferWidth, int BufferHeight, int ScreenWidth, int ScreenHeight, bool BufferFirst); |
||||
|
void PixelSpace(int Left, int Top, int Width, int Height, bool); |
||||
|
#ifdef _WIN32 |
||||
|
COORD GetCoordinates(int BytesRead, int BufferWidth); |
||||
|
#endif |
||||
|
void Log(LogTypes::LOG_LEVELS, const char *Text); |
||||
|
void ClearScreen(bool Cursor = true); |
||||
|
|
||||
|
private: |
||||
|
#ifdef _WIN32 |
||||
|
HWND GetHwnd(void); |
||||
|
HANDLE hConsole; |
||||
|
#endif |
||||
|
bool bUseColor; |
||||
|
}; |
||||
|
|
||||
|
#endif // _CONSOLELISTENER_H |
||||
@ -0,0 +1,81 @@ |
|||||
|
// Copyright 2013 Dolphin Emulator Project |
||||
|
// Licensed under GPLv2 |
||||
|
// Refer to the license.txt file included. |
||||
|
|
||||
|
|
||||
|
// Detect the cpu, so we'll know which optimizations to use |
||||
|
#ifndef _CPUDETECT_H_ |
||||
|
#define _CPUDETECT_H_ |
||||
|
|
||||
|
#include <string> |
||||
|
|
||||
|
enum CPUVendor |
||||
|
{ |
||||
|
VENDOR_INTEL = 0, |
||||
|
VENDOR_AMD = 1, |
||||
|
VENDOR_ARM = 2, |
||||
|
VENDOR_OTHER = 3, |
||||
|
}; |
||||
|
|
||||
|
struct CPUInfo |
||||
|
{ |
||||
|
CPUVendor vendor; |
||||
|
|
||||
|
char cpu_string[0x21]; |
||||
|
char brand_string[0x41]; |
||||
|
bool OS64bit; |
||||
|
bool CPU64bit; |
||||
|
bool Mode64bit; |
||||
|
|
||||
|
bool HTT; |
||||
|
int num_cores; |
||||
|
int logical_cpu_count; |
||||
|
|
||||
|
bool bSSE; |
||||
|
bool bSSE2; |
||||
|
bool bSSE3; |
||||
|
bool bSSSE3; |
||||
|
bool bPOPCNT; |
||||
|
bool bSSE4_1; |
||||
|
bool bSSE4_2; |
||||
|
bool bLZCNT; |
||||
|
bool bSSE4A; |
||||
|
bool bAVX; |
||||
|
bool bAES; |
||||
|
bool bLAHFSAHF64; |
||||
|
bool bLongMode; |
||||
|
|
||||
|
// ARM specific CPUInfo |
||||
|
bool bSwp; |
||||
|
bool bHalf; |
||||
|
bool bThumb; |
||||
|
bool bFastMult; |
||||
|
bool bVFP; |
||||
|
bool bEDSP; |
||||
|
bool bThumbEE; |
||||
|
bool bNEON; |
||||
|
bool bVFPv3; |
||||
|
bool bTLS; |
||||
|
bool bVFPv4; |
||||
|
bool bIDIVa; |
||||
|
bool bIDIVt; |
||||
|
bool bArmV7; // enable MOVT, MOVW etc |
||||
|
|
||||
|
// ARMv8 specific |
||||
|
bool bFP; |
||||
|
bool bASIMD; |
||||
|
|
||||
|
// Call Detect() |
||||
|
explicit CPUInfo(); |
||||
|
|
||||
|
// Turn the cpu info into a string we can show |
||||
|
std::string Summarize(); |
||||
|
|
||||
|
private: |
||||
|
// Detects the various cpu features |
||||
|
void Detect(); |
||||
|
}; |
||||
|
|
||||
|
extern CPUInfo cpu_info; |
||||
|
|
||||
|
#endif // _CPUDETECT_H_ |
||||
@ -0,0 +1,39 @@ |
|||||
|
#ifndef _DEBUGINTERFACE_H |
||||
|
#define _DEBUGINTERFACE_H |
||||
|
|
||||
|
#include <string> |
||||
|
#include <string.h> |
||||
|
|
||||
|
class DebugInterface |
||||
|
{ |
||||
|
protected: |
||||
|
virtual ~DebugInterface() {} |
||||
|
|
||||
|
public: |
||||
|
virtual void disasm(unsigned int /*address*/, char *dest, int /*max_size*/) {strcpy(dest, "NODEBUGGER");} |
||||
|
virtual void getRawMemoryString(int /*memory*/, unsigned int /*address*/, char *dest, int /*max_size*/) {strcpy(dest, "NODEBUGGER");} |
||||
|
virtual int getInstructionSize(int /*instruction*/) {return 1;} |
||||
|
virtual bool isAlive() {return true;} |
||||
|
virtual bool isBreakpoint(unsigned int /*address*/) {return false;} |
||||
|
virtual void setBreakpoint(unsigned int /*address*/){} |
||||
|
virtual void clearBreakpoint(unsigned int /*address*/){} |
||||
|
virtual void clearAllBreakpoints() {} |
||||
|
virtual void toggleBreakpoint(unsigned int /*address*/){} |
||||
|
virtual bool isMemCheck(unsigned int /*address*/) {return false;} |
||||
|
virtual void toggleMemCheck(unsigned int /*address*/){} |
||||
|
virtual unsigned int readMemory(unsigned int /*address*/){return 0;} |
||||
|
virtual void writeExtraMemory(int /*memory*/, unsigned int /*value*/, unsigned int /*address*/) {} |
||||
|
virtual unsigned int readExtraMemory(int /*memory*/, unsigned int /*address*/){return 0;} |
||||
|
virtual unsigned int readInstruction(unsigned int /*address*/){return 0;} |
||||
|
virtual unsigned int getPC() {return 0;} |
||||
|
virtual void setPC(unsigned int /*address*/) {} |
||||
|
virtual void step() {} |
||||
|
virtual void runToBreakpoint() {} |
||||
|
virtual void breakNow() {} |
||||
|
virtual void insertBLR(unsigned int /*address*/, unsigned int /*value*/) {} |
||||
|
virtual void showJitResults(unsigned int /*address*/) {}; |
||||
|
virtual int getColor(unsigned int /*address*/){return 0xFFFFFFFF;} |
||||
|
virtual std::string getDescription(unsigned int /*address*/) = 0; |
||||
|
}; |
||||
|
|
||||
|
#endif |
||||
@ -0,0 +1,433 @@ |
|||||
|
// --------------------------------------------------------------------------------------
|
||||
|
//
|
||||
|
// Written by Zoltan Csizmadia, zoltan_csizmadia@yahoo.com
|
||||
|
// For companies(Austin,TX): If you would like to get my resume, send an email.
|
||||
|
//
|
||||
|
// The source is free, but if you want to use it, mention my name and e-mail address
|
||||
|
//
|
||||
|
// History:
|
||||
|
// 1.0 Initial version Zoltan Csizmadia
|
||||
|
// 1.1 WhineCube version Masken
|
||||
|
// 1.2 Dolphin version Masken
|
||||
|
//
|
||||
|
// --------------------------------------------------------------------------------------
|
||||
|
|
||||
|
#if defined(WIN32)
|
||||
|
|
||||
|
#include <windows.h>
|
||||
|
#include <stdio.h>
|
||||
|
#include "extended_trace.h"
|
||||
|
#include "string_util.h"
|
||||
|
using namespace std; |
||||
|
|
||||
|
#include <tchar.h>
|
||||
|
#include <ImageHlp.h>
|
||||
|
|
||||
|
#define BUFFERSIZE 0x200
|
||||
|
#pragma warning(disable:4996)
|
||||
|
|
||||
|
// Unicode safe char* -> TCHAR* conversion
|
||||
|
void PCSTR2LPTSTR( PCSTR lpszIn, LPTSTR lpszOut ) |
||||
|
{ |
||||
|
#if defined(UNICODE)||defined(_UNICODE)
|
||||
|
ULONG index = 0; |
||||
|
PCSTR lpAct = lpszIn; |
||||
|
|
||||
|
for( ; ; lpAct++ ) |
||||
|
{ |
||||
|
lpszOut[index++] = (TCHAR)(*lpAct); |
||||
|
if ( *lpAct == 0 ) |
||||
|
break; |
||||
|
} |
||||
|
#else
|
||||
|
// This is trivial :)
|
||||
|
strcpy( lpszOut, lpszIn ); |
||||
|
#endif
|
||||
|
} |
||||
|
|
||||
|
// Let's figure out the path for the symbol files
|
||||
|
// Search path= ".;%_NT_SYMBOL_PATH%;%_NT_ALTERNATE_SYMBOL_PATH%;%SYSTEMROOT%;%SYSTEMROOT%\System32;" + lpszIniPath
|
||||
|
// Note: There is no size check for lpszSymbolPath!
|
||||
|
static void InitSymbolPath( PSTR lpszSymbolPath, PCSTR lpszIniPath ) |
||||
|
{ |
||||
|
CHAR lpszPath[BUFFERSIZE]; |
||||
|
|
||||
|
// Creating the default path
|
||||
|
// ".;%_NT_SYMBOL_PATH%;%_NT_ALTERNATE_SYMBOL_PATH%;%SYSTEMROOT%;%SYSTEMROOT%\System32;"
|
||||
|
strcpy( lpszSymbolPath, "." ); |
||||
|
|
||||
|
// environment variable _NT_SYMBOL_PATH
|
||||
|
if ( GetEnvironmentVariableA( "_NT_SYMBOL_PATH", lpszPath, BUFFERSIZE ) ) |
||||
|
{ |
||||
|
strcat( lpszSymbolPath, ";" ); |
||||
|
strcat( lpszSymbolPath, lpszPath ); |
||||
|
} |
||||
|
|
||||
|
// environment variable _NT_ALTERNATE_SYMBOL_PATH
|
||||
|
if ( GetEnvironmentVariableA( "_NT_ALTERNATE_SYMBOL_PATH", lpszPath, BUFFERSIZE ) ) |
||||
|
{ |
||||
|
strcat( lpszSymbolPath, ";" ); |
||||
|
strcat( lpszSymbolPath, lpszPath ); |
||||
|
} |
||||
|
|
||||
|
// environment variable SYSTEMROOT
|
||||
|
if ( GetEnvironmentVariableA( "SYSTEMROOT", lpszPath, BUFFERSIZE ) ) |
||||
|
{ |
||||
|
strcat( lpszSymbolPath, ";" ); |
||||
|
strcat( lpszSymbolPath, lpszPath ); |
||||
|
strcat( lpszSymbolPath, ";" ); |
||||
|
|
||||
|
// SYSTEMROOT\System32
|
||||
|
strcat( lpszSymbolPath, lpszPath ); |
||||
|
strcat( lpszSymbolPath, "\\System32" ); |
||||
|
} |
||||
|
|
||||
|
// Add user defined path
|
||||
|
if ( lpszIniPath != NULL ) |
||||
|
if ( lpszIniPath[0] != '\0' ) |
||||
|
{ |
||||
|
strcat( lpszSymbolPath, ";" ); |
||||
|
strcat( lpszSymbolPath, lpszIniPath ); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// Uninitialize the loaded symbol files
|
||||
|
BOOL UninitSymInfo() { |
||||
|
return SymCleanup( GetCurrentProcess() ); |
||||
|
} |
||||
|
|
||||
|
// Initializes the symbol files
|
||||
|
BOOL InitSymInfo( PCSTR lpszInitialSymbolPath ) |
||||
|
{ |
||||
|
CHAR lpszSymbolPath[BUFFERSIZE]; |
||||
|
DWORD symOptions = SymGetOptions(); |
||||
|
|
||||
|
symOptions |= SYMOPT_LOAD_LINES; |
||||
|
symOptions &= ~SYMOPT_UNDNAME; |
||||
|
SymSetOptions( symOptions ); |
||||
|
InitSymbolPath( lpszSymbolPath, lpszInitialSymbolPath ); |
||||
|
|
||||
|
return SymInitialize( GetCurrentProcess(), lpszSymbolPath, TRUE); |
||||
|
} |
||||
|
|
||||
|
// Get the module name from a given address
|
||||
|
static BOOL GetModuleNameFromAddress( UINT address, LPTSTR lpszModule ) |
||||
|
{ |
||||
|
BOOL ret = FALSE; |
||||
|
IMAGEHLP_MODULE moduleInfo; |
||||
|
|
||||
|
::ZeroMemory( &moduleInfo, sizeof(moduleInfo) ); |
||||
|
moduleInfo.SizeOfStruct = sizeof(moduleInfo); |
||||
|
|
||||
|
if ( SymGetModuleInfo( GetCurrentProcess(), (DWORD)address, &moduleInfo ) ) |
||||
|
{ |
||||
|
// Got it!
|
||||
|
PCSTR2LPTSTR( moduleInfo.ModuleName, lpszModule ); |
||||
|
ret = TRUE; |
||||
|
} |
||||
|
else |
||||
|
// Not found :(
|
||||
|
_tcscpy( lpszModule, _T("?") ); |
||||
|
|
||||
|
return ret; |
||||
|
} |
||||
|
|
||||
|
// Get function prototype and parameter info from ip address and stack address
|
||||
|
static BOOL GetFunctionInfoFromAddresses( ULONG fnAddress, ULONG stackAddress, LPTSTR lpszSymbol ) |
||||
|
{ |
||||
|
BOOL ret = FALSE; |
||||
|
DWORD dwSymSize = 10000; |
||||
|
TCHAR lpszUnDSymbol[BUFFERSIZE]=_T("?"); |
||||
|
CHAR lpszNonUnicodeUnDSymbol[BUFFERSIZE]="?"; |
||||
|
LPTSTR lpszParamSep = NULL; |
||||
|
LPTSTR lpszParsed = lpszUnDSymbol; |
||||
|
PIMAGEHLP_SYMBOL pSym = (PIMAGEHLP_SYMBOL)GlobalAlloc( GMEM_FIXED, dwSymSize ); |
||||
|
|
||||
|
::ZeroMemory( pSym, dwSymSize ); |
||||
|
pSym->SizeOfStruct = dwSymSize; |
||||
|
pSym->MaxNameLength = dwSymSize - sizeof(IMAGEHLP_SYMBOL); |
||||
|
|
||||
|
// Set the default to unknown
|
||||
|
_tcscpy( lpszSymbol, _T("?") ); |
||||
|
|
||||
|
// Get symbol info for IP
|
||||
|
#ifndef _M_X64
|
||||
|
DWORD dwDisp = 0; |
||||
|
if ( SymGetSymFromAddr( GetCurrentProcess(), (ULONG)fnAddress, &dwDisp, pSym ) ) |
||||
|
#else
|
||||
|
//makes it compile but hell im not sure if this works...
|
||||
|
DWORD64 dwDisp = 0; |
||||
|
if ( SymGetSymFromAddr( GetCurrentProcess(), (ULONG)fnAddress, (PDWORD64)&dwDisp, pSym ) ) |
||||
|
#endif
|
||||
|
{ |
||||
|
// Make the symbol readable for humans
|
||||
|
UnDecorateSymbolName( pSym->Name, lpszNonUnicodeUnDSymbol, BUFFERSIZE, |
||||
|
UNDNAME_COMPLETE | |
||||
|
UNDNAME_NO_THISTYPE | |
||||
|
UNDNAME_NO_SPECIAL_SYMS | |
||||
|
UNDNAME_NO_MEMBER_TYPE | |
||||
|
UNDNAME_NO_MS_KEYWORDS | |
||||
|
UNDNAME_NO_ACCESS_SPECIFIERS ); |
||||
|
|
||||
|
// Symbol information is ANSI string
|
||||
|
PCSTR2LPTSTR( lpszNonUnicodeUnDSymbol, lpszUnDSymbol ); |
||||
|
|
||||
|
// I am just smarter than the symbol file :)
|
||||
|
if ( _tcscmp(lpszUnDSymbol, _T("_WinMain@16")) == 0 ) |
||||
|
_tcscpy(lpszUnDSymbol, _T("WinMain(HINSTANCE,HINSTANCE,LPCTSTR,int)")); |
||||
|
else |
||||
|
if ( _tcscmp(lpszUnDSymbol, _T("_main")) == 0 ) |
||||
|
_tcscpy(lpszUnDSymbol, _T("main(int,TCHAR * *)")); |
||||
|
else |
||||
|
if ( _tcscmp(lpszUnDSymbol, _T("_mainCRTStartup")) == 0 ) |
||||
|
_tcscpy(lpszUnDSymbol, _T("mainCRTStartup()")); |
||||
|
else |
||||
|
if ( _tcscmp(lpszUnDSymbol, _T("_wmain")) == 0 ) |
||||
|
_tcscpy(lpszUnDSymbol, _T("wmain(int,TCHAR * *,TCHAR * *)")); |
||||
|
else |
||||
|
if ( _tcscmp(lpszUnDSymbol, _T("_wmainCRTStartup")) == 0 ) |
||||
|
_tcscpy(lpszUnDSymbol, _T("wmainCRTStartup()")); |
||||
|
|
||||
|
lpszSymbol[0] = _T('\0'); |
||||
|
|
||||
|
// Let's go through the stack, and modify the function prototype, and insert the actual
|
||||
|
// parameter values from the stack
|
||||
|
if ( _tcsstr( lpszUnDSymbol, _T("(void)") ) == NULL && _tcsstr( lpszUnDSymbol, _T("()") ) == NULL) |
||||
|
{ |
||||
|
ULONG index = 0; |
||||
|
for( ; ; index++ ) |
||||
|
{ |
||||
|
lpszParamSep = _tcschr( lpszParsed, _T(',') ); |
||||
|
if ( lpszParamSep == NULL ) |
||||
|
break; |
||||
|
|
||||
|
*lpszParamSep = _T('\0'); |
||||
|
|
||||
|
_tcscat( lpszSymbol, lpszParsed ); |
||||
|
_stprintf( lpszSymbol + _tcslen(lpszSymbol), _T("=0x%08X,"), *((ULONG*)(stackAddress) + 2 + index) ); |
||||
|
|
||||
|
lpszParsed = lpszParamSep + 1; |
||||
|
} |
||||
|
|
||||
|
lpszParamSep = _tcschr( lpszParsed, _T(')') ); |
||||
|
if ( lpszParamSep != NULL ) |
||||
|
{ |
||||
|
*lpszParamSep = _T('\0'); |
||||
|
|
||||
|
_tcscat( lpszSymbol, lpszParsed ); |
||||
|
_stprintf( lpszSymbol + _tcslen(lpszSymbol), _T("=0x%08X)"), *((ULONG*)(stackAddress) + 2 + index) ); |
||||
|
|
||||
|
lpszParsed = lpszParamSep + 1; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
_tcscat( lpszSymbol, lpszParsed ); |
||||
|
|
||||
|
ret = TRUE; |
||||
|
} |
||||
|
GlobalFree( pSym ); |
||||
|
|
||||
|
return ret; |
||||
|
} |
||||
|
|
||||
|
// Get source file name and line number from IP address
|
||||
|
// The output format is: "sourcefile(linenumber)" or
|
||||
|
// "modulename!address" or
|
||||
|
// "address"
|
||||
|
static BOOL GetSourceInfoFromAddress( UINT address, LPTSTR lpszSourceInfo ) |
||||
|
{ |
||||
|
BOOL ret = FALSE; |
||||
|
IMAGEHLP_LINE lineInfo; |
||||
|
DWORD dwDisp; |
||||
|
TCHAR lpszFileName[BUFFERSIZE] = _T(""); |
||||
|
TCHAR lpModuleInfo[BUFFERSIZE] = _T(""); |
||||
|
|
||||
|
_tcscpy( lpszSourceInfo, _T("?(?)") ); |
||||
|
|
||||
|
::ZeroMemory( &lineInfo, sizeof( lineInfo ) ); |
||||
|
lineInfo.SizeOfStruct = sizeof( lineInfo ); |
||||
|
|
||||
|
if ( SymGetLineFromAddr( GetCurrentProcess(), address, &dwDisp, &lineInfo ) ) |
||||
|
{ |
||||
|
// Got it. Let's use "sourcefile(linenumber)" format
|
||||
|
PCSTR2LPTSTR( lineInfo.FileName, lpszFileName ); |
||||
|
TCHAR fname[_MAX_FNAME]; |
||||
|
TCHAR ext[_MAX_EXT]; |
||||
|
_tsplitpath(lpszFileName, NULL, NULL, fname, ext); |
||||
|
_stprintf( lpszSourceInfo, _T("%s%s(%d)"), fname, ext, lineInfo.LineNumber ); |
||||
|
ret = TRUE; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
// There is no source file information. :(
|
||||
|
// Let's use the "modulename!address" format
|
||||
|
GetModuleNameFromAddress( address, lpModuleInfo ); |
||||
|
|
||||
|
if ( lpModuleInfo[0] == _T('?') || lpModuleInfo[0] == _T('\0')) |
||||
|
// There is no modulename information. :((
|
||||
|
// Let's use the "address" format
|
||||
|
_stprintf( lpszSourceInfo, _T("0x%08X"), address ); |
||||
|
else |
||||
|
_stprintf( lpszSourceInfo, _T("%s!0x%08X"), lpModuleInfo, address ); |
||||
|
|
||||
|
ret = FALSE; |
||||
|
} |
||||
|
|
||||
|
return ret; |
||||
|
} |
||||
|
|
||||
|
void PrintFunctionAndSourceInfo(FILE* file, const STACKFRAME& callstack) |
||||
|
{ |
||||
|
TCHAR symInfo[BUFFERSIZE] = _T("?"); |
||||
|
TCHAR srcInfo[BUFFERSIZE] = _T("?"); |
||||
|
|
||||
|
GetFunctionInfoFromAddresses((ULONG)callstack.AddrPC.Offset, (ULONG)callstack.AddrFrame.Offset, symInfo); |
||||
|
GetSourceInfoFromAddress((ULONG)callstack.AddrPC.Offset, srcInfo); |
||||
|
etfprint(file, " " + TStrToUTF8(srcInfo) + " : " + TStrToUTF8(symInfo) + "\n"); |
||||
|
} |
||||
|
|
||||
|
void StackTrace( HANDLE hThread, const char* lpszMessage, FILE *file ) |
||||
|
{ |
||||
|
STACKFRAME callStack; |
||||
|
BOOL bResult; |
||||
|
CONTEXT context; |
||||
|
HANDLE hProcess = GetCurrentProcess(); |
||||
|
|
||||
|
// If it's not this thread, let's suspend it, and resume it at the end
|
||||
|
if ( hThread != GetCurrentThread() ) |
||||
|
if ( SuspendThread( hThread ) == -1 ) |
||||
|
{ |
||||
|
// whaaat ?!
|
||||
|
etfprint(file, "Call stack info failed\n"); |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
::ZeroMemory( &context, sizeof(context) ); |
||||
|
context.ContextFlags = CONTEXT_FULL; |
||||
|
|
||||
|
if ( !GetThreadContext( hThread, &context ) ) |
||||
|
{ |
||||
|
etfprint(file, "Call stack info failed\n"); |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
::ZeroMemory( &callStack, sizeof(callStack) ); |
||||
|
#ifndef _M_X64
|
||||
|
callStack.AddrPC.Offset = context.Eip; |
||||
|
callStack.AddrStack.Offset = context.Esp; |
||||
|
callStack.AddrFrame.Offset = context.Ebp; |
||||
|
#else
|
||||
|
callStack.AddrPC.Offset = context.Rip; |
||||
|
callStack.AddrStack.Offset = context.Rsp; |
||||
|
callStack.AddrFrame.Offset = context.Rbp; |
||||
|
#endif
|
||||
|
callStack.AddrPC.Mode = AddrModeFlat; |
||||
|
callStack.AddrStack.Mode = AddrModeFlat; |
||||
|
callStack.AddrFrame.Mode = AddrModeFlat; |
||||
|
|
||||
|
etfprint(file, "Call stack info: \n"); |
||||
|
etfprint(file, lpszMessage); |
||||
|
|
||||
|
PrintFunctionAndSourceInfo(file, callStack); |
||||
|
|
||||
|
for( ULONG index = 0; ; index++ ) |
||||
|
{ |
||||
|
bResult = StackWalk( |
||||
|
IMAGE_FILE_MACHINE_I386, |
||||
|
hProcess, |
||||
|
hThread, |
||||
|
&callStack, |
||||
|
NULL, |
||||
|
NULL, |
||||
|
SymFunctionTableAccess, |
||||
|
SymGetModuleBase, |
||||
|
NULL); |
||||
|
|
||||
|
if ( index == 0 ) |
||||
|
continue; |
||||
|
|
||||
|
if( !bResult || callStack.AddrFrame.Offset == 0 ) |
||||
|
break; |
||||
|
|
||||
|
PrintFunctionAndSourceInfo(file, callStack); |
||||
|
|
||||
|
} |
||||
|
|
||||
|
if ( hThread != GetCurrentThread() ) |
||||
|
ResumeThread( hThread ); |
||||
|
} |
||||
|
|
||||
|
void StackTrace(HANDLE hThread, const char* lpszMessage, FILE *file, DWORD eip, DWORD esp, DWORD ebp ) |
||||
|
{ |
||||
|
STACKFRAME callStack; |
||||
|
BOOL bResult; |
||||
|
TCHAR symInfo[BUFFERSIZE] = _T("?"); |
||||
|
TCHAR srcInfo[BUFFERSIZE] = _T("?"); |
||||
|
HANDLE hProcess = GetCurrentProcess(); |
||||
|
|
||||
|
// If it's not this thread, let's suspend it, and resume it at the end
|
||||
|
if ( hThread != GetCurrentThread() ) |
||||
|
if ( SuspendThread( hThread ) == -1 ) |
||||
|
{ |
||||
|
// whaaat ?!
|
||||
|
etfprint(file, "Call stack info failed\n"); |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
::ZeroMemory( &callStack, sizeof(callStack) ); |
||||
|
callStack.AddrPC.Offset = eip; |
||||
|
callStack.AddrStack.Offset = esp; |
||||
|
callStack.AddrFrame.Offset = ebp; |
||||
|
callStack.AddrPC.Mode = AddrModeFlat; |
||||
|
callStack.AddrStack.Mode = AddrModeFlat; |
||||
|
callStack.AddrFrame.Mode = AddrModeFlat; |
||||
|
|
||||
|
etfprint(file, "Call stack info: \n"); |
||||
|
etfprint(file, lpszMessage); |
||||
|
|
||||
|
PrintFunctionAndSourceInfo(file, callStack); |
||||
|
|
||||
|
for( ULONG index = 0; ; index++ ) |
||||
|
{ |
||||
|
bResult = StackWalk( |
||||
|
IMAGE_FILE_MACHINE_I386, |
||||
|
hProcess, |
||||
|
hThread, |
||||
|
&callStack, |
||||
|
NULL, |
||||
|
NULL, |
||||
|
SymFunctionTableAccess, |
||||
|
SymGetModuleBase, |
||||
|
NULL); |
||||
|
|
||||
|
if ( index == 0 ) |
||||
|
continue; |
||||
|
|
||||
|
if( !bResult || callStack.AddrFrame.Offset == 0 ) |
||||
|
break; |
||||
|
|
||||
|
PrintFunctionAndSourceInfo(file, callStack); |
||||
|
} |
||||
|
|
||||
|
if ( hThread != GetCurrentThread() ) |
||||
|
ResumeThread( hThread ); |
||||
|
} |
||||
|
|
||||
|
char g_uefbuf[2048]; |
||||
|
|
||||
|
void etfprintf(FILE *file, const char *format, ...) |
||||
|
{ |
||||
|
va_list ap; |
||||
|
va_start(ap, format); |
||||
|
int len = vsprintf(g_uefbuf, format, ap); |
||||
|
fwrite(g_uefbuf, 1, len, file); |
||||
|
va_end(ap); |
||||
|
} |
||||
|
|
||||
|
void etfprint(FILE *file, const std::string &text) |
||||
|
{ |
||||
|
size_t len = text.length(); |
||||
|
fwrite(text.data(), 1, len, file); |
||||
|
} |
||||
|
|
||||
|
#endif //WIN32
|
||||
@ -0,0 +1,53 @@ |
|||||
|
// ----------------------------------------------------------------------------------------- |
||||
|
// |
||||
|
// Written by Zoltan Csizmadia, zoltan_csizmadia@yahoo.com |
||||
|
// For companies(Austin,TX): If you would like to get my resume, send an email. |
||||
|
// |
||||
|
// The source is free, but if you want to use it, mention my name and e-mail address |
||||
|
// |
||||
|
// History: |
||||
|
// 1.0 Initial version Zoltan Csizmadia |
||||
|
// 1.1 WhineCube version Masken |
||||
|
// 1.2 Dolphin version Masken |
||||
|
// |
||||
|
// ---------------------------------------------------------------------------------------- |
||||
|
|
||||
|
#ifndef _EXTENDEDTRACE_H_INCLUDED_ |
||||
|
#define _EXTENDEDTRACE_H_INCLUDED_ |
||||
|
|
||||
|
#if defined(WIN32) |
||||
|
|
||||
|
#include <windows.h> |
||||
|
#include <tchar.h> |
||||
|
|
||||
|
#include <string> |
||||
|
|
||||
|
#pragma comment( lib, "imagehlp.lib" ) |
||||
|
|
||||
|
#define EXTENDEDTRACEINITIALIZE( IniSymbolPath ) InitSymInfo( IniSymbolPath ) |
||||
|
#define EXTENDEDTRACEUNINITIALIZE() UninitSymInfo() |
||||
|
#define STACKTRACE(file) StackTrace( GetCurrentThread(), "", file) |
||||
|
#define STACKTRACE2(file, eip, esp, ebp) StackTrace(GetCurrentThread(), "", file, eip, esp, ebp) |
||||
|
// class File; |
||||
|
|
||||
|
BOOL InitSymInfo( PCSTR ); |
||||
|
BOOL UninitSymInfo(); |
||||
|
void StackTrace(HANDLE, char const* msg, FILE *file); |
||||
|
void StackTrace(HANDLE, char const* msg, FILE *file, DWORD eip, DWORD esp, DWORD ebp); |
||||
|
|
||||
|
// functions by Masken |
||||
|
void etfprintf(FILE *file, const char *format, ...); |
||||
|
void etfprint(FILE *file, const std::string &text); |
||||
|
#define UEFBUFSIZE 2048 |
||||
|
extern char g_uefbuf[UEFBUFSIZE]; |
||||
|
|
||||
|
#else // not WIN32 |
||||
|
|
||||
|
#define EXTENDEDTRACEINITIALIZE( IniSymbolPath ) ((void)0) |
||||
|
#define EXTENDEDTRACEUNINITIALIZE() ((void)0) |
||||
|
#define STACKTRACE(file) ((void)0) |
||||
|
#define STACKTRACE2(file, eip, esp, ebp) ((void)0) |
||||
|
|
||||
|
#endif // WIN32 |
||||
|
|
||||
|
#endif // _EXTENDEDTRACE_H_INCLUDED_ |
||||
@ -0,0 +1,115 @@ |
|||||
|
|
||||
|
#ifndef _FIFO_QUEUE_H_ |
||||
|
#define _FIFO_QUEUE_H_ |
||||
|
|
||||
|
// a simple lockless thread-safe, |
||||
|
// single reader, single writer queue |
||||
|
|
||||
|
#include "atomic.h" |
||||
|
|
||||
|
namespace Common |
||||
|
{ |
||||
|
|
||||
|
template <typename T> |
||||
|
class FifoQueue |
||||
|
{ |
||||
|
public: |
||||
|
FifoQueue() : m_size(0) |
||||
|
{ |
||||
|
m_write_ptr = m_read_ptr = new ElementPtr(); |
||||
|
} |
||||
|
|
||||
|
~FifoQueue() |
||||
|
{ |
||||
|
// this will empty out the whole queue |
||||
|
delete m_read_ptr; |
||||
|
} |
||||
|
|
||||
|
u32 Size() const |
||||
|
{ |
||||
|
return m_size; |
||||
|
} |
||||
|
|
||||
|
bool Empty() const |
||||
|
{ |
||||
|
//return (m_read_ptr == m_write_ptr); |
||||
|
return (0 == m_size); |
||||
|
} |
||||
|
|
||||
|
T& Front() const |
||||
|
{ |
||||
|
return *m_read_ptr->current; |
||||
|
} |
||||
|
|
||||
|
template <typename Arg> |
||||
|
void Push(Arg&& t) |
||||
|
{ |
||||
|
// create the element, add it to the queue |
||||
|
m_write_ptr->current = new T(std::forward<Arg>(t)); |
||||
|
// set the next pointer to a new element ptr |
||||
|
// then advance the write pointer |
||||
|
m_write_ptr = m_write_ptr->next = new ElementPtr(); |
||||
|
Common::AtomicIncrement(m_size); |
||||
|
} |
||||
|
|
||||
|
void Pop() |
||||
|
{ |
||||
|
Common::AtomicDecrement(m_size); |
||||
|
ElementPtr *const tmpptr = m_read_ptr; |
||||
|
// advance the read pointer |
||||
|
m_read_ptr = m_read_ptr->next; |
||||
|
// set the next element to NULL to stop the recursive deletion |
||||
|
tmpptr->next = NULL; |
||||
|
delete tmpptr; // this also deletes the element |
||||
|
} |
||||
|
|
||||
|
bool Pop(T& t) |
||||
|
{ |
||||
|
if (Empty()) |
||||
|
return false; |
||||
|
|
||||
|
t = std::move(Front()); |
||||
|
Pop(); |
||||
|
|
||||
|
return true; |
||||
|
} |
||||
|
|
||||
|
// not thread-safe |
||||
|
void Clear() |
||||
|
{ |
||||
|
m_size = 0; |
||||
|
delete m_read_ptr; |
||||
|
m_write_ptr = m_read_ptr = new ElementPtr(); |
||||
|
} |
||||
|
|
||||
|
private: |
||||
|
// stores a pointer to element |
||||
|
// and a pointer to the next ElementPtr |
||||
|
class ElementPtr |
||||
|
{ |
||||
|
public: |
||||
|
ElementPtr() : current(NULL), next(NULL) {} |
||||
|
|
||||
|
~ElementPtr() |
||||
|
{ |
||||
|
if (current) |
||||
|
{ |
||||
|
delete current; |
||||
|
// recusion ftw |
||||
|
if (next) |
||||
|
delete next; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
T *volatile current; |
||||
|
ElementPtr *volatile next; |
||||
|
}; |
||||
|
|
||||
|
ElementPtr *volatile m_write_ptr; |
||||
|
ElementPtr *volatile m_read_ptr; |
||||
|
volatile u32 m_size; |
||||
|
}; |
||||
|
|
||||
|
} |
||||
|
|
||||
|
#endif |
||||
@ -0,0 +1,106 @@ |
|||||
|
// Copyright 2013 Dolphin Emulator Project
|
||||
|
// Licensed under GPLv2
|
||||
|
// Refer to the license.txt file included.
|
||||
|
|
||||
|
|
||||
|
#include "common.h"
|
||||
|
#include "common_paths.h"
|
||||
|
#ifndef _WIN32
|
||||
|
#include <sys/types.h>
|
||||
|
#include <dirent.h>
|
||||
|
#else
|
||||
|
#include <windows.h>
|
||||
|
#endif
|
||||
|
|
||||
|
#include <string>
|
||||
|
#include <algorithm>
|
||||
|
|
||||
|
#include "file_search.h"
|
||||
|
|
||||
|
#include "string_util.h"
|
||||
|
|
||||
|
|
||||
|
CFileSearch::CFileSearch(const CFileSearch::XStringVector& _rSearchStrings, const CFileSearch::XStringVector& _rDirectories) |
||||
|
{ |
||||
|
// Reverse the loop order for speed?
|
||||
|
for (size_t j = 0; j < _rSearchStrings.size(); j++) |
||||
|
{ |
||||
|
for (size_t i = 0; i < _rDirectories.size(); i++) |
||||
|
{ |
||||
|
FindFiles(_rSearchStrings[j], _rDirectories[i]); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void CFileSearch::FindFiles(const std::string& _searchString, const std::string& _strPath) |
||||
|
{ |
||||
|
std::string GCMSearchPath; |
||||
|
BuildCompleteFilename(GCMSearchPath, _strPath, _searchString); |
||||
|
#ifdef _WIN32
|
||||
|
WIN32_FIND_DATA findData; |
||||
|
HANDLE FindFirst = FindFirstFile(UTF8ToTStr(GCMSearchPath).c_str(), &findData); |
||||
|
|
||||
|
if (FindFirst != INVALID_HANDLE_VALUE) |
||||
|
{ |
||||
|
bool bkeepLooping = true; |
||||
|
|
||||
|
while (bkeepLooping) |
||||
|
{ |
||||
|
if (findData.cFileName[0] != '.') |
||||
|
{ |
||||
|
std::string strFilename; |
||||
|
BuildCompleteFilename(strFilename, _strPath, TStrToUTF8(findData.cFileName)); |
||||
|
m_FileNames.push_back(strFilename); |
||||
|
} |
||||
|
|
||||
|
bkeepLooping = FindNextFile(FindFirst, &findData) ? true : false; |
||||
|
} |
||||
|
} |
||||
|
FindClose(FindFirst); |
||||
|
|
||||
|
|
||||
|
#else
|
||||
|
// TODO: super lame/broken
|
||||
|
|
||||
|
auto end_match(_searchString); |
||||
|
|
||||
|
// assuming we have a "*.blah"-like pattern
|
||||
|
if (!end_match.empty() && end_match[0] == '*') |
||||
|
end_match.erase(0, 1); |
||||
|
|
||||
|
// ugly
|
||||
|
if (end_match == ".*") |
||||
|
end_match.clear(); |
||||
|
|
||||
|
DIR* dir = opendir(_strPath.c_str()); |
||||
|
|
||||
|
if (!dir) |
||||
|
return; |
||||
|
|
||||
|
while (auto const dp = readdir(dir)) |
||||
|
{ |
||||
|
std::string found(dp->d_name); |
||||
|
|
||||
|
if ((found != ".") && (found != "..") |
||||
|
&& (found.size() >= end_match.size()) |
||||
|
&& std::equal(end_match.rbegin(), end_match.rend(), found.rbegin())) |
||||
|
{ |
||||
|
std::string full_name; |
||||
|
if (_strPath.c_str()[_strPath.size()-1] == DIR_SEP_CHR) |
||||
|
full_name = _strPath + found; |
||||
|
else |
||||
|
full_name = _strPath + DIR_SEP + found; |
||||
|
|
||||
|
m_FileNames.push_back(full_name); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
closedir(dir); |
||||
|
#endif
|
||||
|
} |
||||
|
|
||||
|
const CFileSearch::XStringVector& CFileSearch::GetFileNames() const |
||||
|
{ |
||||
|
return m_FileNames; |
||||
|
} |
||||
@ -0,0 +1,28 @@ |
|||||
|
// Copyright 2013 Dolphin Emulator Project |
||||
|
// Licensed under GPLv2 |
||||
|
// Refer to the license.txt file included. |
||||
|
|
||||
|
|
||||
|
#ifndef _FILESEARCH_H_ |
||||
|
#define _FILESEARCH_H_ |
||||
|
|
||||
|
#include <string> |
||||
|
#include <vector> |
||||
|
|
||||
|
class CFileSearch |
||||
|
{ |
||||
|
public: |
||||
|
typedef std::vector<std::string>XStringVector; |
||||
|
|
||||
|
CFileSearch(const XStringVector& _rSearchStrings, const XStringVector& _rDirectories); |
||||
|
const XStringVector& GetFileNames() const; |
||||
|
|
||||
|
private: |
||||
|
|
||||
|
void FindFiles(const std::string& _searchString, const std::string& _strPath); |
||||
|
|
||||
|
XStringVector m_FileNames; |
||||
|
}; |
||||
|
|
||||
|
#endif // _FILESEARCH_H_ |
||||
|
|
||||
@ -0,0 +1,922 @@ |
|||||
|
// Copyright 2013 Dolphin Emulator Project
|
||||
|
// Licensed under GPLv2
|
||||
|
// Refer to the license.txt file included.
|
||||
|
|
||||
|
|
||||
|
#include "common.h"
|
||||
|
#include "common_paths.h"
|
||||
|
#include "file_util.h"
|
||||
|
#include "string_util.h"
|
||||
|
|
||||
|
#ifdef _WIN32
|
||||
|
#include <windows.h>
|
||||
|
#include <shlobj.h> // for SHGetFolderPath
|
||||
|
#include <shellapi.h>
|
||||
|
#include <commdlg.h> // for GetSaveFileName
|
||||
|
#include <io.h>
|
||||
|
#include <direct.h> // getcwd
|
||||
|
#else
|
||||
|
#include <sys/param.h>
|
||||
|
#include <sys/types.h>
|
||||
|
#include <dirent.h>
|
||||
|
#include <errno.h>
|
||||
|
#include <stdlib.h>
|
||||
|
#endif
|
||||
|
|
||||
|
#if defined(__APPLE__)
|
||||
|
#include <CoreFoundation/CFString.h>
|
||||
|
#include <CoreFoundation/CFURL.h>
|
||||
|
#include <CoreFoundation/CFBundle.h>
|
||||
|
#endif
|
||||
|
|
||||
|
#include <algorithm>
|
||||
|
#include <sys/stat.h>
|
||||
|
|
||||
|
#include "string_util.h"
|
||||
|
|
||||
|
#ifndef S_ISDIR
|
||||
|
#define S_ISDIR(m) (((m)&S_IFMT) == S_IFDIR)
|
||||
|
#endif
|
||||
|
|
||||
|
#ifdef BSD4_4
|
||||
|
#define stat64 stat
|
||||
|
#define fstat64 fstat
|
||||
|
#endif
|
||||
|
|
||||
|
// This namespace has various generic functions related to files and paths.
|
||||
|
// The code still needs a ton of cleanup.
|
||||
|
// REMEMBER: strdup considered harmful!
|
||||
|
namespace File |
||||
|
{ |
||||
|
|
||||
|
// Remove any ending forward slashes from directory paths
|
||||
|
// Modifies argument.
|
||||
|
static void StripTailDirSlashes(std::string &fname) |
||||
|
{ |
||||
|
if (fname.length() > 1) |
||||
|
{ |
||||
|
size_t i = fname.length() - 1; |
||||
|
while (fname[i] == DIR_SEP_CHR) |
||||
|
fname[i--] = '\0'; |
||||
|
} |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
// Returns true if file filename exists
|
||||
|
bool Exists(const std::string &filename) |
||||
|
{ |
||||
|
struct stat64 file_info; |
||||
|
|
||||
|
std::string copy(filename); |
||||
|
StripTailDirSlashes(copy); |
||||
|
|
||||
|
#ifdef _WIN32
|
||||
|
int result = _tstat64(UTF8ToTStr(copy).c_str(), &file_info); |
||||
|
#else
|
||||
|
int result = stat64(copy.c_str(), &file_info); |
||||
|
#endif
|
||||
|
|
||||
|
return (result == 0); |
||||
|
} |
||||
|
|
||||
|
// Returns true if filename is a directory
|
||||
|
bool IsDirectory(const std::string &filename) |
||||
|
{ |
||||
|
struct stat64 file_info; |
||||
|
|
||||
|
std::string copy(filename); |
||||
|
StripTailDirSlashes(copy); |
||||
|
|
||||
|
#ifdef _WIN32
|
||||
|
int result = _tstat64(UTF8ToTStr(copy).c_str(), &file_info); |
||||
|
#else
|
||||
|
int result = stat64(copy.c_str(), &file_info); |
||||
|
#endif
|
||||
|
|
||||
|
if (result < 0) { |
||||
|
WARN_LOG(COMMON, "IsDirectory: stat failed on %s: %s", |
||||
|
filename.c_str(), GetLastErrorMsg()); |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
return S_ISDIR(file_info.st_mode); |
||||
|
} |
||||
|
|
||||
|
// Deletes a given filename, return true on success
|
||||
|
// Doesn't supports deleting a directory
|
||||
|
bool Delete(const std::string &filename) |
||||
|
{ |
||||
|
INFO_LOG(COMMON, "Delete: file %s", filename.c_str()); |
||||
|
|
||||
|
// Return true because we care about the file no
|
||||
|
// being there, not the actual delete.
|
||||
|
if (!Exists(filename)) |
||||
|
{ |
||||
|
WARN_LOG(COMMON, "Delete: %s does not exist", filename.c_str()); |
||||
|
return true; |
||||
|
} |
||||
|
|
||||
|
// We can't delete a directory
|
||||
|
if (IsDirectory(filename)) |
||||
|
{ |
||||
|
WARN_LOG(COMMON, "Delete failed: %s is a directory", filename.c_str()); |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
#ifdef _WIN32
|
||||
|
if (!DeleteFile(UTF8ToTStr(filename).c_str())) |
||||
|
{ |
||||
|
WARN_LOG(COMMON, "Delete: DeleteFile failed on %s: %s", |
||||
|
filename.c_str(), GetLastErrorMsg()); |
||||
|
return false; |
||||
|
} |
||||
|
#else
|
||||
|
if (unlink(filename.c_str()) == -1) { |
||||
|
WARN_LOG(COMMON, "Delete: unlink failed on %s: %s", |
||||
|
filename.c_str(), GetLastErrorMsg()); |
||||
|
return false; |
||||
|
} |
||||
|
#endif
|
||||
|
|
||||
|
return true; |
||||
|
} |
||||
|
|
||||
|
// Returns true if successful, or path already exists.
|
||||
|
bool CreateDir(const std::string &path) |
||||
|
{ |
||||
|
INFO_LOG(COMMON, "CreateDir: directory %s", path.c_str()); |
||||
|
#ifdef _WIN32
|
||||
|
if (::CreateDirectory(UTF8ToTStr(path).c_str(), NULL)) |
||||
|
return true; |
||||
|
DWORD error = GetLastError(); |
||||
|
if (error == ERROR_ALREADY_EXISTS) |
||||
|
{ |
||||
|
WARN_LOG(COMMON, "CreateDir: CreateDirectory failed on %s: already exists", path.c_str()); |
||||
|
return true; |
||||
|
} |
||||
|
ERROR_LOG(COMMON, "CreateDir: CreateDirectory failed on %s: %i", path.c_str(), error); |
||||
|
return false; |
||||
|
#else
|
||||
|
if (mkdir(path.c_str(), 0755) == 0) |
||||
|
return true; |
||||
|
|
||||
|
int err = errno; |
||||
|
|
||||
|
if (err == EEXIST) |
||||
|
{ |
||||
|
WARN_LOG(COMMON, "CreateDir: mkdir failed on %s: already exists", path.c_str()); |
||||
|
return true; |
||||
|
} |
||||
|
|
||||
|
ERROR_LOG(COMMON, "CreateDir: mkdir failed on %s: %s", path.c_str(), strerror(err)); |
||||
|
return false; |
||||
|
#endif
|
||||
|
} |
||||
|
|
||||
|
// Creates the full path of fullPath returns true on success
|
||||
|
bool CreateFullPath(const std::string &fullPath) |
||||
|
{ |
||||
|
int panicCounter = 100; |
||||
|
INFO_LOG(COMMON, "CreateFullPath: path %s", fullPath.c_str()); |
||||
|
|
||||
|
if (File::Exists(fullPath)) |
||||
|
{ |
||||
|
INFO_LOG(COMMON, "CreateFullPath: path exists %s", fullPath.c_str()); |
||||
|
return true; |
||||
|
} |
||||
|
|
||||
|
size_t position = 0; |
||||
|
while (true) |
||||
|
{ |
||||
|
// Find next sub path
|
||||
|
position = fullPath.find(DIR_SEP_CHR, position); |
||||
|
|
||||
|
// we're done, yay!
|
||||
|
if (position == fullPath.npos) |
||||
|
return true; |
||||
|
|
||||
|
// Include the '/' so the first call is CreateDir("/") rather than CreateDir("")
|
||||
|
std::string const subPath(fullPath.substr(0, position + 1)); |
||||
|
if (!File::IsDirectory(subPath)) |
||||
|
File::CreateDir(subPath); |
||||
|
|
||||
|
// A safety check
|
||||
|
panicCounter--; |
||||
|
if (panicCounter <= 0) |
||||
|
{ |
||||
|
ERROR_LOG(COMMON, "CreateFullPath: directory structure is too deep"); |
||||
|
return false; |
||||
|
} |
||||
|
position++; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
|
||||
|
// Deletes a directory filename, returns true on success
|
||||
|
bool DeleteDir(const std::string &filename) |
||||
|
{ |
||||
|
INFO_LOG(COMMON, "DeleteDir: directory %s", filename.c_str()); |
||||
|
|
||||
|
// check if a directory
|
||||
|
if (!File::IsDirectory(filename)) |
||||
|
{ |
||||
|
ERROR_LOG(COMMON, "DeleteDir: Not a directory %s", filename.c_str()); |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
#ifdef _WIN32
|
||||
|
if (::RemoveDirectory(UTF8ToTStr(filename).c_str())) |
||||
|
return true; |
||||
|
#else
|
||||
|
if (rmdir(filename.c_str()) == 0) |
||||
|
return true; |
||||
|
#endif
|
||||
|
ERROR_LOG(COMMON, "DeleteDir: %s: %s", filename.c_str(), GetLastErrorMsg()); |
||||
|
|
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
// renames file srcFilename to destFilename, returns true on success
|
||||
|
bool Rename(const std::string &srcFilename, const std::string &destFilename) |
||||
|
{ |
||||
|
INFO_LOG(COMMON, "Rename: %s --> %s", |
||||
|
srcFilename.c_str(), destFilename.c_str()); |
||||
|
if (rename(srcFilename.c_str(), destFilename.c_str()) == 0) |
||||
|
return true; |
||||
|
ERROR_LOG(COMMON, "Rename: failed %s --> %s: %s", |
||||
|
srcFilename.c_str(), destFilename.c_str(), GetLastErrorMsg()); |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
// copies file srcFilename to destFilename, returns true on success
|
||||
|
bool Copy(const std::string &srcFilename, const std::string &destFilename) |
||||
|
{ |
||||
|
INFO_LOG(COMMON, "Copy: %s --> %s", |
||||
|
srcFilename.c_str(), destFilename.c_str()); |
||||
|
#ifdef _WIN32
|
||||
|
if (CopyFile(UTF8ToTStr(srcFilename).c_str(), UTF8ToTStr(destFilename).c_str(), FALSE)) |
||||
|
return true; |
||||
|
|
||||
|
ERROR_LOG(COMMON, "Copy: failed %s --> %s: %s", |
||||
|
srcFilename.c_str(), destFilename.c_str(), GetLastErrorMsg()); |
||||
|
return false; |
||||
|
#else
|
||||
|
|
||||
|
// buffer size
|
||||
|
#define BSIZE 1024
|
||||
|
|
||||
|
char buffer[BSIZE]; |
||||
|
|
||||
|
// Open input file
|
||||
|
FILE *input = fopen(srcFilename.c_str(), "rb"); |
||||
|
if (!input) |
||||
|
{ |
||||
|
ERROR_LOG(COMMON, "Copy: input failed %s --> %s: %s", |
||||
|
srcFilename.c_str(), destFilename.c_str(), GetLastErrorMsg()); |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
// open output file
|
||||
|
FILE *output = fopen(destFilename.c_str(), "wb"); |
||||
|
if (!output) |
||||
|
{ |
||||
|
fclose(input); |
||||
|
ERROR_LOG(COMMON, "Copy: output failed %s --> %s: %s", |
||||
|
srcFilename.c_str(), destFilename.c_str(), GetLastErrorMsg()); |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
// copy loop
|
||||
|
while (!feof(input)) |
||||
|
{ |
||||
|
// read input
|
||||
|
int rnum = fread(buffer, sizeof(char), BSIZE, input); |
||||
|
if (rnum != BSIZE) |
||||
|
{ |
||||
|
if (ferror(input) != 0) |
||||
|
{ |
||||
|
ERROR_LOG(COMMON, |
||||
|
"Copy: failed reading from source, %s --> %s: %s", |
||||
|
srcFilename.c_str(), destFilename.c_str(), GetLastErrorMsg()); |
||||
|
goto bail; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// write output
|
||||
|
int wnum = fwrite(buffer, sizeof(char), rnum, output); |
||||
|
if (wnum != rnum) |
||||
|
{ |
||||
|
ERROR_LOG(COMMON, |
||||
|
"Copy: failed writing to output, %s --> %s: %s", |
||||
|
srcFilename.c_str(), destFilename.c_str(), GetLastErrorMsg()); |
||||
|
goto bail; |
||||
|
} |
||||
|
} |
||||
|
// close files
|
||||
|
fclose(input); |
||||
|
fclose(output); |
||||
|
return true; |
||||
|
bail: |
||||
|
if (input) |
||||
|
fclose(input); |
||||
|
if (output) |
||||
|
fclose(output); |
||||
|
return false; |
||||
|
#endif
|
||||
|
} |
||||
|
|
||||
|
// Returns the size of filename (64bit)
|
||||
|
u64 GetSize(const std::string &filename) |
||||
|
{ |
||||
|
if (!Exists(filename)) |
||||
|
{ |
||||
|
WARN_LOG(COMMON, "GetSize: failed %s: No such file", filename.c_str()); |
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
|
if (IsDirectory(filename)) |
||||
|
{ |
||||
|
WARN_LOG(COMMON, "GetSize: failed %s: is a directory", filename.c_str()); |
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
|
struct stat64 buf; |
||||
|
#ifdef _WIN32
|
||||
|
if (_tstat64(UTF8ToTStr(filename).c_str(), &buf) == 0) |
||||
|
#else
|
||||
|
if (stat64(filename.c_str(), &buf) == 0) |
||||
|
#endif
|
||||
|
{ |
||||
|
DEBUG_LOG(COMMON, "GetSize: %s: %lld", |
||||
|
filename.c_str(), (long long)buf.st_size); |
||||
|
return buf.st_size; |
||||
|
} |
||||
|
|
||||
|
ERROR_LOG(COMMON, "GetSize: Stat failed %s: %s", |
||||
|
filename.c_str(), GetLastErrorMsg()); |
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
|
// Overloaded GetSize, accepts file descriptor
|
||||
|
u64 GetSize(const int fd) |
||||
|
{ |
||||
|
struct stat64 buf; |
||||
|
if (fstat64(fd, &buf) != 0) { |
||||
|
ERROR_LOG(COMMON, "GetSize: stat failed %i: %s", |
||||
|
fd, GetLastErrorMsg()); |
||||
|
return 0; |
||||
|
} |
||||
|
return buf.st_size; |
||||
|
} |
||||
|
|
||||
|
// Overloaded GetSize, accepts FILE*
|
||||
|
u64 GetSize(FILE *f) |
||||
|
{ |
||||
|
// can't use off_t here because it can be 32-bit
|
||||
|
u64 pos = ftello(f); |
||||
|
if (fseeko(f, 0, SEEK_END) != 0) { |
||||
|
ERROR_LOG(COMMON, "GetSize: seek failed %p: %s", |
||||
|
f, GetLastErrorMsg()); |
||||
|
return 0; |
||||
|
} |
||||
|
u64 size = ftello(f); |
||||
|
if ((size != pos) && (fseeko(f, pos, SEEK_SET) != 0)) { |
||||
|
ERROR_LOG(COMMON, "GetSize: seek failed %p: %s", |
||||
|
f, GetLastErrorMsg()); |
||||
|
return 0; |
||||
|
} |
||||
|
return size; |
||||
|
} |
||||
|
|
||||
|
// creates an empty file filename, returns true on success
|
||||
|
bool CreateEmptyFile(const std::string &filename) |
||||
|
{ |
||||
|
INFO_LOG(COMMON, "CreateEmptyFile: %s", filename.c_str()); |
||||
|
|
||||
|
if (!File::IOFile(filename, "wb")) |
||||
|
{ |
||||
|
ERROR_LOG(COMMON, "CreateEmptyFile: failed %s: %s", |
||||
|
filename.c_str(), GetLastErrorMsg()); |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
return true; |
||||
|
} |
||||
|
|
||||
|
|
||||
|
// Scans the directory tree gets, starting from _Directory and adds the
|
||||
|
// results into parentEntry. Returns the number of files+directories found
|
||||
|
u32 ScanDirectoryTree(const std::string &directory, FSTEntry& parentEntry) |
||||
|
{ |
||||
|
INFO_LOG(COMMON, "ScanDirectoryTree: directory %s", directory.c_str()); |
||||
|
// How many files + directories we found
|
||||
|
u32 foundEntries = 0; |
||||
|
#ifdef _WIN32
|
||||
|
// Find the first file in the directory.
|
||||
|
WIN32_FIND_DATA ffd; |
||||
|
|
||||
|
HANDLE hFind = FindFirstFile(UTF8ToTStr(directory + "\\*").c_str(), &ffd); |
||||
|
if (hFind == INVALID_HANDLE_VALUE) |
||||
|
{ |
||||
|
FindClose(hFind); |
||||
|
return foundEntries; |
||||
|
} |
||||
|
// windows loop
|
||||
|
do |
||||
|
{ |
||||
|
FSTEntry entry; |
||||
|
const std::string virtualName(TStrToUTF8(ffd.cFileName)); |
||||
|
#else
|
||||
|
struct dirent dirent, *result = NULL; |
||||
|
|
||||
|
DIR *dirp = opendir(directory.c_str()); |
||||
|
if (!dirp) |
||||
|
return 0; |
||||
|
|
||||
|
// non windows loop
|
||||
|
while (!readdir_r(dirp, &dirent, &result) && result) |
||||
|
{ |
||||
|
FSTEntry entry; |
||||
|
const std::string virtualName(result->d_name); |
||||
|
#endif
|
||||
|
// check for "." and ".."
|
||||
|
if (((virtualName[0] == '.') && (virtualName[1] == '\0')) || |
||||
|
((virtualName[0] == '.') && (virtualName[1] == '.') && |
||||
|
(virtualName[2] == '\0'))) |
||||
|
continue; |
||||
|
entry.virtualName = virtualName; |
||||
|
entry.physicalName = directory; |
||||
|
entry.physicalName += DIR_SEP + entry.virtualName; |
||||
|
|
||||
|
if (IsDirectory(entry.physicalName.c_str())) |
||||
|
{ |
||||
|
entry.isDirectory = true; |
||||
|
// is a directory, lets go inside
|
||||
|
entry.size = ScanDirectoryTree(entry.physicalName, entry); |
||||
|
foundEntries += (u32)entry.size; |
||||
|
} |
||||
|
else |
||||
|
{ // is a file
|
||||
|
entry.isDirectory = false; |
||||
|
entry.size = GetSize(entry.physicalName.c_str()); |
||||
|
} |
||||
|
++foundEntries; |
||||
|
// Push into the tree
|
||||
|
parentEntry.children.push_back(entry); |
||||
|
#ifdef _WIN32
|
||||
|
} while (FindNextFile(hFind, &ffd) != 0); |
||||
|
FindClose(hFind); |
||||
|
#else
|
||||
|
} |
||||
|
closedir(dirp); |
||||
|
#endif
|
||||
|
// Return number of entries found.
|
||||
|
return foundEntries; |
||||
|
} |
||||
|
|
||||
|
|
||||
|
// Deletes the given directory and anything under it. Returns true on success.
|
||||
|
bool DeleteDirRecursively(const std::string &directory) |
||||
|
{ |
||||
|
INFO_LOG(COMMON, "DeleteDirRecursively: %s", directory.c_str()); |
||||
|
#ifdef _WIN32
|
||||
|
// Find the first file in the directory.
|
||||
|
WIN32_FIND_DATA ffd; |
||||
|
HANDLE hFind = FindFirstFile(UTF8ToTStr(directory + "\\*").c_str(), &ffd); |
||||
|
|
||||
|
if (hFind == INVALID_HANDLE_VALUE) |
||||
|
{ |
||||
|
FindClose(hFind); |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
// windows loop
|
||||
|
do |
||||
|
{ |
||||
|
const std::string virtualName(TStrToUTF8(ffd.cFileName)); |
||||
|
#else
|
||||
|
struct dirent dirent, *result = NULL; |
||||
|
DIR *dirp = opendir(directory.c_str()); |
||||
|
if (!dirp) |
||||
|
return false; |
||||
|
|
||||
|
// non windows loop
|
||||
|
while (!readdir_r(dirp, &dirent, &result) && result) |
||||
|
{ |
||||
|
const std::string virtualName = result->d_name; |
||||
|
#endif
|
||||
|
|
||||
|
// check for "." and ".."
|
||||
|
if (((virtualName[0] == '.') && (virtualName[1] == '\0')) || |
||||
|
((virtualName[0] == '.') && (virtualName[1] == '.') && |
||||
|
(virtualName[2] == '\0'))) |
||||
|
continue; |
||||
|
|
||||
|
std::string newPath = directory + DIR_SEP_CHR + virtualName; |
||||
|
if (IsDirectory(newPath)) |
||||
|
{ |
||||
|
if (!DeleteDirRecursively(newPath)) |
||||
|
{ |
||||
|
#ifndef _WIN32
|
||||
|
closedir(dirp); |
||||
|
#endif
|
||||
|
|
||||
|
return false; |
||||
|
} |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
if (!File::Delete(newPath)) |
||||
|
{ |
||||
|
#ifndef _WIN32
|
||||
|
closedir(dirp); |
||||
|
#endif
|
||||
|
|
||||
|
return false; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
#ifdef _WIN32
|
||||
|
} while (FindNextFile(hFind, &ffd) != 0); |
||||
|
FindClose(hFind); |
||||
|
#else
|
||||
|
} |
||||
|
closedir(dirp); |
||||
|
#endif
|
||||
|
File::DeleteDir(directory); |
||||
|
|
||||
|
return true; |
||||
|
} |
||||
|
|
||||
|
// Create directory and copy contents (does not overwrite existing files)
|
||||
|
void CopyDir(const std::string &source_path, const std::string &dest_path) |
||||
|
{ |
||||
|
#ifndef _WIN32
|
||||
|
if (source_path == dest_path) return; |
||||
|
if (!File::Exists(source_path)) return; |
||||
|
if (!File::Exists(dest_path)) File::CreateFullPath(dest_path); |
||||
|
|
||||
|
struct dirent dirent, *result = NULL; |
||||
|
DIR *dirp = opendir(source_path.c_str()); |
||||
|
if (!dirp) return; |
||||
|
|
||||
|
while (!readdir_r(dirp, &dirent, &result) && result) |
||||
|
{ |
||||
|
const std::string virtualName(result->d_name); |
||||
|
// check for "." and ".."
|
||||
|
if (((virtualName[0] == '.') && (virtualName[1] == '\0')) || |
||||
|
((virtualName[0] == '.') && (virtualName[1] == '.') && |
||||
|
(virtualName[2] == '\0'))) |
||||
|
continue; |
||||
|
|
||||
|
std::string source, dest; |
||||
|
source = source_path + virtualName; |
||||
|
dest = dest_path + virtualName; |
||||
|
if (IsDirectory(source)) |
||||
|
{ |
||||
|
source += '/'; |
||||
|
dest += '/'; |
||||
|
if (!File::Exists(dest)) File::CreateFullPath(dest); |
||||
|
CopyDir(source, dest); |
||||
|
} |
||||
|
else if (!File::Exists(dest)) File::Copy(source, dest); |
||||
|
} |
||||
|
closedir(dirp); |
||||
|
#endif
|
||||
|
} |
||||
|
|
||||
|
// Returns the current directory
|
||||
|
std::string GetCurrentDir() |
||||
|
{ |
||||
|
char *dir; |
||||
|
// Get the current working directory (getcwd uses malloc)
|
||||
|
if (!(dir = __getcwd(NULL, 0))) { |
||||
|
|
||||
|
ERROR_LOG(COMMON, "GetCurrentDirectory failed: %s", |
||||
|
GetLastErrorMsg()); |
||||
|
return NULL; |
||||
|
} |
||||
|
std::string strDir = dir; |
||||
|
free(dir); |
||||
|
return strDir; |
||||
|
} |
||||
|
|
||||
|
// Sets the current directory to the given directory
|
||||
|
bool SetCurrentDir(const std::string &directory) |
||||
|
{ |
||||
|
return __chdir(directory.c_str()) == 0; |
||||
|
} |
||||
|
|
||||
|
#if defined(__APPLE__)
|
||||
|
std::string GetBundleDirectory() |
||||
|
{ |
||||
|
CFURLRef BundleRef; |
||||
|
char AppBundlePath[MAXPATHLEN]; |
||||
|
// Get the main bundle for the app
|
||||
|
BundleRef = CFBundleCopyBundleURL(CFBundleGetMainBundle()); |
||||
|
CFStringRef BundlePath = CFURLCopyFileSystemPath(BundleRef, kCFURLPOSIXPathStyle); |
||||
|
CFStringGetFileSystemRepresentation(BundlePath, AppBundlePath, sizeof(AppBundlePath)); |
||||
|
CFRelease(BundleRef); |
||||
|
CFRelease(BundlePath); |
||||
|
|
||||
|
return AppBundlePath; |
||||
|
} |
||||
|
#endif
|
||||
|
|
||||
|
#ifdef _WIN32
|
||||
|
std::string& GetExeDirectory() |
||||
|
{ |
||||
|
static std::string DolphinPath; |
||||
|
if (DolphinPath.empty()) |
||||
|
{ |
||||
|
TCHAR Dolphin_exe_Path[2048]; |
||||
|
GetModuleFileName(NULL, Dolphin_exe_Path, 2048); |
||||
|
DolphinPath = TStrToUTF8(Dolphin_exe_Path); |
||||
|
DolphinPath = DolphinPath.substr(0, DolphinPath.find_last_of('\\')); |
||||
|
} |
||||
|
return DolphinPath; |
||||
|
} |
||||
|
#endif
|
||||
|
|
||||
|
std::string GetSysDirectory() |
||||
|
{ |
||||
|
std::string sysDir; |
||||
|
|
||||
|
#if defined (__APPLE__)
|
||||
|
sysDir = GetBundleDirectory(); |
||||
|
sysDir += DIR_SEP; |
||||
|
sysDir += SYSDATA_DIR; |
||||
|
#else
|
||||
|
sysDir = SYSDATA_DIR; |
||||
|
#endif
|
||||
|
sysDir += DIR_SEP; |
||||
|
|
||||
|
INFO_LOG(COMMON, "GetSysDirectory: Setting to %s:", sysDir.c_str()); |
||||
|
return sysDir; |
||||
|
} |
||||
|
|
||||
|
// Returns a string with a Dolphin data dir or file in the user's home
|
||||
|
// directory. To be used in "multi-user" mode (that is, installed).
|
||||
|
//const std::string& GetUserPath(const unsigned int DirIDX, const std::string &newPath)
|
||||
|
//{
|
||||
|
// static std::string paths[NUM_PATH_INDICES];
|
||||
|
//
|
||||
|
// // Set up all paths and files on the first run
|
||||
|
// if (paths[D_USER_IDX].empty())
|
||||
|
// {
|
||||
|
//#ifdef _WIN32
|
||||
|
// paths[D_USER_IDX] = GetExeDirectory() + DIR_SEP USERDATA_DIR DIR_SEP;
|
||||
|
//#else
|
||||
|
// if (File::Exists(ROOT_DIR DIR_SEP USERDATA_DIR))
|
||||
|
// paths[D_USER_IDX] = ROOT_DIR DIR_SEP USERDATA_DIR DIR_SEP;
|
||||
|
// else
|
||||
|
// paths[D_USER_IDX] = std::string(getenv("HOME") ?
|
||||
|
// getenv("HOME") : getenv("PWD") ?
|
||||
|
// getenv("PWD") : "") + DIR_SEP DOLPHIN_DATA_DIR DIR_SEP;
|
||||
|
//#endif
|
||||
|
//
|
||||
|
// paths[D_CONFIG_IDX] = paths[D_USER_IDX] + CONFIG_DIR DIR_SEP;
|
||||
|
// paths[D_GAMECONFIG_IDX] = paths[D_USER_IDX] + GAMECONFIG_DIR DIR_SEP;
|
||||
|
// paths[D_MAPS_IDX] = paths[D_USER_IDX] + MAPS_DIR DIR_SEP;
|
||||
|
// paths[D_CACHE_IDX] = paths[D_USER_IDX] + CACHE_DIR DIR_SEP;
|
||||
|
// paths[D_SHADERCACHE_IDX] = paths[D_USER_IDX] + SHADERCACHE_DIR DIR_SEP;
|
||||
|
// paths[D_SHADERS_IDX] = paths[D_USER_IDX] + SHADERS_DIR DIR_SEP;
|
||||
|
// paths[D_STATESAVES_IDX] = paths[D_USER_IDX] + STATESAVES_DIR DIR_SEP;
|
||||
|
// paths[D_SCREENSHOTS_IDX] = paths[D_USER_IDX] + SCREENSHOTS_DIR DIR_SEP;
|
||||
|
// paths[D_DUMP_IDX] = paths[D_USER_IDX] + DUMP_DIR DIR_SEP;
|
||||
|
// paths[D_DUMPFRAMES_IDX] = paths[D_DUMP_IDX] + DUMP_FRAMES_DIR DIR_SEP;
|
||||
|
// paths[D_DUMPAUDIO_IDX] = paths[D_DUMP_IDX] + DUMP_AUDIO_DIR DIR_SEP;
|
||||
|
// paths[D_DUMPTEXTURES_IDX] = paths[D_DUMP_IDX] + DUMP_TEXTURES_DIR DIR_SEP;
|
||||
|
// paths[D_LOGS_IDX] = paths[D_USER_IDX] + LOGS_DIR DIR_SEP;
|
||||
|
// paths[F_DEBUGGERCONFIG_IDX] = paths[D_CONFIG_IDX] + DEBUGGER_CONFIG;
|
||||
|
// paths[F_LOGGERCONFIG_IDX] = paths[D_CONFIG_IDX] + LOGGER_CONFIG;
|
||||
|
// paths[F_MAINLOG_IDX] = paths[D_LOGS_IDX] + MAIN_LOG;
|
||||
|
// }
|
||||
|
//
|
||||
|
// if (!newPath.empty())
|
||||
|
// {
|
||||
|
// if (!File::IsDirectory(newPath))
|
||||
|
// {
|
||||
|
// WARN_LOG(COMMON, "Invalid path specified %s", newPath.c_str());
|
||||
|
// return paths[DirIDX];
|
||||
|
// }
|
||||
|
// else
|
||||
|
// {
|
||||
|
// paths[DirIDX] = newPath;
|
||||
|
// }
|
||||
|
//
|
||||
|
// switch (DirIDX)
|
||||
|
// {
|
||||
|
// case D_WIIROOT_IDX:
|
||||
|
// paths[D_WIIUSER_IDX] = paths[D_WIIROOT_IDX] + DIR_SEP;
|
||||
|
// paths[D_WIISYSCONF_IDX] = paths[D_WIIUSER_IDX] + WII_SYSCONF_DIR + DIR_SEP;
|
||||
|
// paths[F_WIISYSCONF_IDX] = paths[D_WIISYSCONF_IDX] + WII_SYSCONF;
|
||||
|
// break;
|
||||
|
//
|
||||
|
// case D_USER_IDX:
|
||||
|
// paths[D_GCUSER_IDX] = paths[D_USER_IDX] + GC_USER_DIR DIR_SEP;
|
||||
|
// paths[D_WIIROOT_IDX] = paths[D_USER_IDX] + WII_USER_DIR;
|
||||
|
// paths[D_WIIUSER_IDX] = paths[D_WIIROOT_IDX] + DIR_SEP;
|
||||
|
// paths[D_CONFIG_IDX] = paths[D_USER_IDX] + CONFIG_DIR DIR_SEP;
|
||||
|
// paths[D_GAMECONFIG_IDX] = paths[D_USER_IDX] + GAMECONFIG_DIR DIR_SEP;
|
||||
|
// paths[D_MAPS_IDX] = paths[D_USER_IDX] + MAPS_DIR DIR_SEP;
|
||||
|
// paths[D_CACHE_IDX] = paths[D_USER_IDX] + CACHE_DIR DIR_SEP;
|
||||
|
// paths[D_SHADERCACHE_IDX] = paths[D_USER_IDX] + SHADERCACHE_DIR DIR_SEP;
|
||||
|
// paths[D_SHADERS_IDX] = paths[D_USER_IDX] + SHADERS_DIR DIR_SEP;
|
||||
|
// paths[D_STATESAVES_IDX] = paths[D_USER_IDX] + STATESAVES_DIR DIR_SEP;
|
||||
|
// paths[D_SCREENSHOTS_IDX] = paths[D_USER_IDX] + SCREENSHOTS_DIR DIR_SEP;
|
||||
|
// paths[D_OPENCL_IDX] = paths[D_USER_IDX] + OPENCL_DIR DIR_SEP;
|
||||
|
// paths[D_HIRESTEXTURES_IDX] = paths[D_USER_IDX] + HIRES_TEXTURES_DIR DIR_SEP;
|
||||
|
// paths[D_DUMP_IDX] = paths[D_USER_IDX] + DUMP_DIR DIR_SEP;
|
||||
|
// paths[D_DUMPFRAMES_IDX] = paths[D_DUMP_IDX] + DUMP_FRAMES_DIR DIR_SEP;
|
||||
|
// paths[D_DUMPAUDIO_IDX] = paths[D_DUMP_IDX] + DUMP_AUDIO_DIR DIR_SEP;
|
||||
|
// paths[D_DUMPTEXTURES_IDX] = paths[D_DUMP_IDX] + DUMP_TEXTURES_DIR DIR_SEP;
|
||||
|
// paths[D_DUMPDSP_IDX] = paths[D_DUMP_IDX] + DUMP_DSP_DIR DIR_SEP;
|
||||
|
// paths[D_LOGS_IDX] = paths[D_USER_IDX] + LOGS_DIR DIR_SEP;
|
||||
|
// paths[D_MAILLOGS_IDX] = paths[D_LOGS_IDX] + MAIL_LOGS_DIR DIR_SEP;
|
||||
|
// paths[D_WIISYSCONF_IDX] = paths[D_WIIUSER_IDX] + WII_SYSCONF_DIR DIR_SEP;
|
||||
|
// paths[D_THEMES_IDX] = paths[D_USER_IDX] + THEMES_DIR DIR_SEP;
|
||||
|
// paths[F_DOLPHINCONFIG_IDX] = paths[D_CONFIG_IDX] + DOLPHIN_CONFIG;
|
||||
|
// paths[F_DEBUGGERCONFIG_IDX] = paths[D_CONFIG_IDX] + DEBUGGER_CONFIG;
|
||||
|
// paths[F_LOGGERCONFIG_IDX] = paths[D_CONFIG_IDX] + LOGGER_CONFIG;
|
||||
|
// paths[F_MAINLOG_IDX] = paths[D_LOGS_IDX] + MAIN_LOG;
|
||||
|
// paths[F_WIISYSCONF_IDX] = paths[D_WIISYSCONF_IDX] + WII_SYSCONF;
|
||||
|
// paths[F_RAMDUMP_IDX] = paths[D_DUMP_IDX] + RAM_DUMP;
|
||||
|
// paths[F_ARAMDUMP_IDX] = paths[D_DUMP_IDX] + ARAM_DUMP;
|
||||
|
// paths[F_FAKEVMEMDUMP_IDX] = paths[D_DUMP_IDX] + FAKEVMEM_DUMP;
|
||||
|
// paths[F_GCSRAM_IDX] = paths[D_GCUSER_IDX] + GC_SRAM;
|
||||
|
// break;
|
||||
|
//
|
||||
|
// case D_CONFIG_IDX:
|
||||
|
// paths[F_DOLPHINCONFIG_IDX] = paths[D_CONFIG_IDX] + DOLPHIN_CONFIG;
|
||||
|
// paths[F_DEBUGGERCONFIG_IDX] = paths[D_CONFIG_IDX] + DEBUGGER_CONFIG;
|
||||
|
// paths[F_LOGGERCONFIG_IDX] = paths[D_CONFIG_IDX] + LOGGER_CONFIG;
|
||||
|
// break;
|
||||
|
//
|
||||
|
// case D_DUMP_IDX:
|
||||
|
// paths[D_DUMPFRAMES_IDX] = paths[D_DUMP_IDX] + DUMP_FRAMES_DIR DIR_SEP;
|
||||
|
// paths[D_DUMPAUDIO_IDX] = paths[D_DUMP_IDX] + DUMP_AUDIO_DIR DIR_SEP;
|
||||
|
// paths[D_DUMPTEXTURES_IDX] = paths[D_DUMP_IDX] + DUMP_TEXTURES_DIR DIR_SEP;
|
||||
|
// break;
|
||||
|
//
|
||||
|
// case D_LOGS_IDX:
|
||||
|
// paths[F_MAINLOG_IDX] = paths[D_LOGS_IDX] + MAIN_LOG;
|
||||
|
// }
|
||||
|
// }
|
||||
|
//
|
||||
|
// return paths[DirIDX];
|
||||
|
//}
|
||||
|
|
||||
|
std::string GetThemeDir(const std::string& theme_name) |
||||
|
{ |
||||
|
std::string dir = File::GetUserPath(D_THEMES_IDX) + theme_name + "/"; |
||||
|
|
||||
|
#if !defined(_WIN32)
|
||||
|
// If theme does not exist in user's dir load from shared directory
|
||||
|
if (!File::Exists(dir)) |
||||
|
dir = SHARED_USER_DIR THEMES_DIR "/" + theme_name + "/"; |
||||
|
#endif
|
||||
|
|
||||
|
return dir; |
||||
|
} |
||||
|
|
||||
|
bool WriteStringToFile(bool text_file, const std::string &str, const char *filename) |
||||
|
{ |
||||
|
return File::IOFile(filename, text_file ? "w" : "wb").WriteBytes(str.data(), str.size()); |
||||
|
} |
||||
|
|
||||
|
bool ReadFileToString(bool text_file, const char *filename, std::string &str) |
||||
|
{ |
||||
|
File::IOFile file(filename, text_file ? "r" : "rb"); |
||||
|
auto const f = file.GetHandle(); |
||||
|
|
||||
|
if (!f) |
||||
|
return false; |
||||
|
|
||||
|
str.resize(GetSize(f)); |
||||
|
return file.ReadArray(&str[0], str.size()); |
||||
|
} |
||||
|
|
||||
|
IOFile::IOFile() |
||||
|
: m_file(NULL), m_good(true) |
||||
|
{} |
||||
|
|
||||
|
IOFile::IOFile(std::FILE* file) |
||||
|
: m_file(file), m_good(true) |
||||
|
{} |
||||
|
|
||||
|
IOFile::IOFile(const std::string& filename, const char openmode[]) |
||||
|
: m_file(NULL), m_good(true) |
||||
|
{ |
||||
|
Open(filename, openmode); |
||||
|
} |
||||
|
|
||||
|
IOFile::~IOFile() |
||||
|
{ |
||||
|
Close(); |
||||
|
} |
||||
|
|
||||
|
IOFile::IOFile(IOFile&& other) |
||||
|
: m_file(NULL), m_good(true) |
||||
|
{ |
||||
|
Swap(other); |
||||
|
} |
||||
|
|
||||
|
IOFile& IOFile::operator=(IOFile&& other) |
||||
|
{ |
||||
|
Swap(other); |
||||
|
return *this; |
||||
|
} |
||||
|
|
||||
|
void IOFile::Swap(IOFile& other) |
||||
|
{ |
||||
|
std::swap(m_file, other.m_file); |
||||
|
std::swap(m_good, other.m_good); |
||||
|
} |
||||
|
|
||||
|
bool IOFile::Open(const std::string& filename, const char openmode[]) |
||||
|
{ |
||||
|
Close(); |
||||
|
#ifdef _WIN32
|
||||
|
_tfopen_s(&m_file, UTF8ToTStr(filename).c_str(), UTF8ToTStr(openmode).c_str()); |
||||
|
#else
|
||||
|
m_file = fopen(filename.c_str(), openmode); |
||||
|
#endif
|
||||
|
|
||||
|
m_good = IsOpen(); |
||||
|
return m_good; |
||||
|
} |
||||
|
|
||||
|
bool IOFile::Close() |
||||
|
{ |
||||
|
if (!IsOpen() || 0 != std::fclose(m_file)) |
||||
|
m_good = false; |
||||
|
|
||||
|
m_file = NULL; |
||||
|
return m_good; |
||||
|
} |
||||
|
|
||||
|
std::FILE* IOFile::ReleaseHandle() |
||||
|
{ |
||||
|
std::FILE* const ret = m_file; |
||||
|
m_file = NULL; |
||||
|
return ret; |
||||
|
} |
||||
|
|
||||
|
void IOFile::SetHandle(std::FILE* file) |
||||
|
{ |
||||
|
Close(); |
||||
|
Clear(); |
||||
|
m_file = file; |
||||
|
} |
||||
|
|
||||
|
u64 IOFile::GetSize() |
||||
|
{ |
||||
|
if (IsOpen()) |
||||
|
return File::GetSize(m_file); |
||||
|
else |
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
|
bool IOFile::Seek(s64 off, int origin) |
||||
|
{ |
||||
|
if (!IsOpen() || 0 != fseeko(m_file, off, origin)) |
||||
|
m_good = false; |
||||
|
|
||||
|
return m_good; |
||||
|
} |
||||
|
|
||||
|
u64 IOFile::Tell() |
||||
|
{ |
||||
|
if (IsOpen()) |
||||
|
return ftello(m_file); |
||||
|
else |
||||
|
return -1; |
||||
|
} |
||||
|
|
||||
|
bool IOFile::Flush() |
||||
|
{ |
||||
|
if (!IsOpen() || 0 != std::fflush(m_file)) |
||||
|
m_good = false; |
||||
|
|
||||
|
return m_good; |
||||
|
} |
||||
|
|
||||
|
bool IOFile::Resize(u64 size) |
||||
|
{ |
||||
|
if (!IsOpen() || 0 != |
||||
|
#ifdef _WIN32
|
||||
|
// ector: _chsize sucks, not 64-bit safe
|
||||
|
// F|RES: changed to _chsize_s. i think it is 64-bit safe
|
||||
|
_chsize_s(_fileno(m_file), size) |
||||
|
#else
|
||||
|
// TODO: handle 64bit and growing
|
||||
|
ftruncate(fileno(m_file), size) |
||||
|
#endif
|
||||
|
) |
||||
|
m_good = false; |
||||
|
|
||||
|
return m_good; |
||||
|
} |
||||
|
|
||||
|
} // namespace
|
||||
@ -0,0 +1,232 @@ |
|||||
|
// Copyright 2013 Dolphin Emulator Project |
||||
|
// Licensed under GPLv2 |
||||
|
// Refer to the license.txt file included. |
||||
|
|
||||
|
|
||||
|
#ifndef _FILEUTIL_H_ |
||||
|
#define _FILEUTIL_H_ |
||||
|
|
||||
|
#include <fstream> |
||||
|
#include <cstdio> |
||||
|
#include <string> |
||||
|
#include <vector> |
||||
|
#include <string.h> |
||||
|
|
||||
|
#include "common.h" |
||||
|
#include "string_util.h" |
||||
|
|
||||
|
// User directory indices for GetUserPath |
||||
|
enum { |
||||
|
D_USER_IDX, |
||||
|
D_GCUSER_IDX, |
||||
|
D_WIIROOT_IDX, |
||||
|
D_WIIUSER_IDX, |
||||
|
D_CONFIG_IDX, |
||||
|
D_GAMECONFIG_IDX, |
||||
|
D_MAPS_IDX, |
||||
|
D_CACHE_IDX, |
||||
|
D_SHADERCACHE_IDX, |
||||
|
D_SHADERS_IDX, |
||||
|
D_STATESAVES_IDX, |
||||
|
D_SCREENSHOTS_IDX, |
||||
|
D_OPENCL_IDX, |
||||
|
D_HIRESTEXTURES_IDX, |
||||
|
D_DUMP_IDX, |
||||
|
D_DUMPFRAMES_IDX, |
||||
|
D_DUMPAUDIO_IDX, |
||||
|
D_DUMPTEXTURES_IDX, |
||||
|
D_DUMPDSP_IDX, |
||||
|
D_LOGS_IDX, |
||||
|
D_MAILLOGS_IDX, |
||||
|
D_WIISYSCONF_IDX, |
||||
|
D_WIIWC24_IDX, |
||||
|
D_THEMES_IDX, |
||||
|
F_DOLPHINCONFIG_IDX, |
||||
|
F_DEBUGGERCONFIG_IDX, |
||||
|
F_LOGGERCONFIG_IDX, |
||||
|
F_MAINLOG_IDX, |
||||
|
F_WIISYSCONF_IDX, |
||||
|
F_RAMDUMP_IDX, |
||||
|
F_ARAMDUMP_IDX, |
||||
|
F_FAKEVMEMDUMP_IDX, |
||||
|
F_GCSRAM_IDX, |
||||
|
NUM_PATH_INDICES |
||||
|
}; |
||||
|
|
||||
|
namespace File |
||||
|
{ |
||||
|
|
||||
|
// FileSystem tree node/ |
||||
|
struct FSTEntry |
||||
|
{ |
||||
|
bool isDirectory; |
||||
|
u64 size; // file length or number of entries from children |
||||
|
std::string physicalName; // name on disk |
||||
|
std::string virtualName; // name in FST names table |
||||
|
std::vector<FSTEntry> children; |
||||
|
}; |
||||
|
|
||||
|
// Returns true if file filename exists |
||||
|
bool Exists(const std::string &filename); |
||||
|
|
||||
|
// Returns true if filename is a directory |
||||
|
bool IsDirectory(const std::string &filename); |
||||
|
|
||||
|
// Returns the size of filename (64bit) |
||||
|
u64 GetSize(const std::string &filename); |
||||
|
|
||||
|
// Overloaded GetSize, accepts file descriptor |
||||
|
u64 GetSize(const int fd); |
||||
|
|
||||
|
// Overloaded GetSize, accepts FILE* |
||||
|
u64 GetSize(FILE *f); |
||||
|
|
||||
|
// Returns true if successful, or path already exists. |
||||
|
bool CreateDir(const std::string &filename); |
||||
|
|
||||
|
// Creates the full path of fullPath returns true on success |
||||
|
bool CreateFullPath(const std::string &fullPath); |
||||
|
|
||||
|
// Deletes a given filename, return true on success |
||||
|
// Doesn't supports deleting a directory |
||||
|
bool Delete(const std::string &filename); |
||||
|
|
||||
|
// Deletes a directory filename, returns true on success |
||||
|
bool DeleteDir(const std::string &filename); |
||||
|
|
||||
|
// renames file srcFilename to destFilename, returns true on success |
||||
|
bool Rename(const std::string &srcFilename, const std::string &destFilename); |
||||
|
|
||||
|
// copies file srcFilename to destFilename, returns true on success |
||||
|
bool Copy(const std::string &srcFilename, const std::string &destFilename); |
||||
|
|
||||
|
// creates an empty file filename, returns true on success |
||||
|
bool CreateEmptyFile(const std::string &filename); |
||||
|
|
||||
|
// Scans the directory tree gets, starting from _Directory and adds the |
||||
|
// results into parentEntry. Returns the number of files+directories found |
||||
|
u32 ScanDirectoryTree(const std::string &directory, FSTEntry& parentEntry); |
||||
|
|
||||
|
// deletes the given directory and anything under it. Returns true on success. |
||||
|
bool DeleteDirRecursively(const std::string &directory); |
||||
|
|
||||
|
// Returns the current directory |
||||
|
std::string GetCurrentDir(); |
||||
|
|
||||
|
// Create directory and copy contents (does not overwrite existing files) |
||||
|
void CopyDir(const std::string &source_path, const std::string &dest_path); |
||||
|
|
||||
|
// Set the current directory to given directory |
||||
|
bool SetCurrentDir(const std::string &directory); |
||||
|
|
||||
|
// Returns a pointer to a string with a Dolphin data dir in the user's home |
||||
|
// directory. To be used in "multi-user" mode (that is, installed). |
||||
|
const std::string& GetUserPath(const unsigned int DirIDX, const std::string &newPath=""); |
||||
|
|
||||
|
// probably doesn't belong here |
||||
|
std::string GetThemeDir(const std::string& theme_name); |
||||
|
|
||||
|
// Returns the path to where the sys file are |
||||
|
std::string GetSysDirectory(); |
||||
|
|
||||
|
#ifdef __APPLE__ |
||||
|
std::string GetBundleDirectory(); |
||||
|
#endif |
||||
|
|
||||
|
#ifdef _WIN32 |
||||
|
std::string &GetExeDirectory(); |
||||
|
#endif |
||||
|
|
||||
|
bool WriteStringToFile(bool text_file, const std::string &str, const char *filename); |
||||
|
bool ReadFileToString(bool text_file, const char *filename, std::string &str); |
||||
|
|
||||
|
// simple wrapper for cstdlib file functions to |
||||
|
// hopefully will make error checking easier |
||||
|
// and make forgetting an fclose() harder |
||||
|
class IOFile : public NonCopyable |
||||
|
{ |
||||
|
public: |
||||
|
IOFile(); |
||||
|
IOFile(std::FILE* file); |
||||
|
IOFile(const std::string& filename, const char openmode[]); |
||||
|
|
||||
|
~IOFile(); |
||||
|
|
||||
|
IOFile(IOFile&& other); |
||||
|
IOFile& operator=(IOFile&& other); |
||||
|
|
||||
|
void Swap(IOFile& other); |
||||
|
|
||||
|
bool Open(const std::string& filename, const char openmode[]); |
||||
|
bool Close(); |
||||
|
|
||||
|
template <typename T> |
||||
|
bool ReadArray(T* data, size_t length) |
||||
|
{ |
||||
|
if (!IsOpen() || length != std::fread(data, sizeof(T), length, m_file)) |
||||
|
m_good = false; |
||||
|
|
||||
|
return m_good; |
||||
|
} |
||||
|
|
||||
|
template <typename T> |
||||
|
bool WriteArray(const T* data, size_t length) |
||||
|
{ |
||||
|
if (!IsOpen() || length != std::fwrite(data, sizeof(T), length, m_file)) |
||||
|
m_good = false; |
||||
|
|
||||
|
return m_good; |
||||
|
} |
||||
|
|
||||
|
bool ReadBytes(void* data, size_t length) |
||||
|
{ |
||||
|
return ReadArray(reinterpret_cast<char*>(data), length); |
||||
|
} |
||||
|
|
||||
|
bool WriteBytes(const void* data, size_t length) |
||||
|
{ |
||||
|
return WriteArray(reinterpret_cast<const char*>(data), length); |
||||
|
} |
||||
|
|
||||
|
bool IsOpen() { return NULL != m_file; } |
||||
|
|
||||
|
// m_good is set to false when a read, write or other function fails |
||||
|
bool IsGood() { return m_good; } |
||||
|
operator void*() { return m_good ? m_file : NULL; } |
||||
|
|
||||
|
std::FILE* ReleaseHandle(); |
||||
|
|
||||
|
std::FILE* GetHandle() { return m_file; } |
||||
|
|
||||
|
void SetHandle(std::FILE* file); |
||||
|
|
||||
|
bool Seek(s64 off, int origin); |
||||
|
u64 Tell(); |
||||
|
u64 GetSize(); |
||||
|
bool Resize(u64 size); |
||||
|
bool Flush(); |
||||
|
|
||||
|
// clear error state |
||||
|
void Clear() { m_good = true; std::clearerr(m_file); } |
||||
|
|
||||
|
std::FILE* m_file; |
||||
|
bool m_good; |
||||
|
private: |
||||
|
IOFile(IOFile&); |
||||
|
IOFile& operator=(IOFile& other); |
||||
|
}; |
||||
|
|
||||
|
} // namespace |
||||
|
|
||||
|
// To deal with Windows being dumb at unicode: |
||||
|
template <typename T> |
||||
|
void OpenFStream(T& fstream, const std::string& filename, std::ios_base::openmode openmode) |
||||
|
{ |
||||
|
#ifdef _WIN32 |
||||
|
fstream.open(UTF8ToTStr(filename).c_str(), openmode); |
||||
|
#else |
||||
|
fstream.open(filename.c_str(), openmode); |
||||
|
#endif |
||||
|
} |
||||
|
|
||||
|
#endif |
||||
@ -0,0 +1,75 @@ |
|||||
|
// Copyright 2013 Dolphin Emulator Project |
||||
|
// Licensed under GPLv2 |
||||
|
// Refer to the license.txt file included. |
||||
|
|
||||
|
|
||||
|
#ifndef _FIXED_SIZE_QUEUE_H_ |
||||
|
#define _FIXED_SIZE_QUEUE_H_ |
||||
|
|
||||
|
// STL-look-a-like interface, but name is mixed case to distinguish it clearly from the |
||||
|
// real STL classes. |
||||
|
|
||||
|
// Not fully featured, no safety checking yet. Add features as needed. |
||||
|
|
||||
|
// TODO: "inline" storage? |
||||
|
|
||||
|
template <class T, int N> |
||||
|
class fixed_size_queue.h |
||||
|
{ |
||||
|
T *storage; |
||||
|
int head; |
||||
|
int tail; |
||||
|
int count; // sacrifice 4 bytes for a simpler implementation. may optimize away in the future. |
||||
|
|
||||
|
// Make copy constructor private for now. |
||||
|
fixed_size_queue.h(fixed_size_queue.h &other) { } |
||||
|
|
||||
|
public: |
||||
|
fixed_size_queue.h() |
||||
|
{ |
||||
|
storage = new T[N]; |
||||
|
clear(); |
||||
|
} |
||||
|
|
||||
|
~fixed_size_queue.h() |
||||
|
{ |
||||
|
delete [] storage; |
||||
|
} |
||||
|
|
||||
|
void clear() { |
||||
|
head = 0; |
||||
|
tail = 0; |
||||
|
count = 0; |
||||
|
} |
||||
|
|
||||
|
void push(T t) { |
||||
|
storage[tail] = t; |
||||
|
tail++; |
||||
|
if (tail == N) |
||||
|
tail = 0; |
||||
|
count++; |
||||
|
} |
||||
|
|
||||
|
void pop() { |
||||
|
head++; |
||||
|
if (head == N) |
||||
|
head = 0; |
||||
|
count--; |
||||
|
} |
||||
|
|
||||
|
T pop_front() { |
||||
|
const T &temp = storage[head]; |
||||
|
pop(); |
||||
|
return temp; |
||||
|
} |
||||
|
|
||||
|
T &front() { return storage[head]; } |
||||
|
const T &front() const { return storage[head]; } |
||||
|
|
||||
|
size_t size() const { |
||||
|
return count; |
||||
|
} |
||||
|
}; |
||||
|
|
||||
|
#endif // _FIXED_SIZE_QUEUE_H_ |
||||
|
|
||||
@ -0,0 +1,520 @@ |
|||||
|
// Copyright 2013 Dolphin Emulator Project
|
||||
|
// Licensed under GPLv2
|
||||
|
// Refer to the license.txt file included.
|
||||
|
|
||||
|
|
||||
|
#include "hash.h"
|
||||
|
#if _M_SSE >= 0x402
|
||||
|
#include "cpu_detect.h"
|
||||
|
#include <nmmintrin.h>
|
||||
|
#endif
|
||||
|
|
||||
|
static u64 (*ptrHashFunction)(const u8 *src, int len, u32 samples) = &GetMurmurHash3; |
||||
|
|
||||
|
// uint32_t
|
||||
|
// WARNING - may read one more byte!
|
||||
|
// Implementation from Wikipedia.
|
||||
|
u32 HashFletcher(const u8* data_u8, size_t length) |
||||
|
{ |
||||
|
const u16* data = (const u16*)data_u8; /* Pointer to the data to be summed */ |
||||
|
size_t len = (length + 1) / 2; /* Length in 16-bit words */ |
||||
|
u32 sum1 = 0xffff, sum2 = 0xffff; |
||||
|
|
||||
|
while (len) |
||||
|
{ |
||||
|
size_t tlen = len > 360 ? 360 : len; |
||||
|
len -= tlen; |
||||
|
|
||||
|
do { |
||||
|
sum1 += *data++; |
||||
|
sum2 += sum1; |
||||
|
} |
||||
|
while (--tlen); |
||||
|
|
||||
|
sum1 = (sum1 & 0xffff) + (sum1 >> 16); |
||||
|
sum2 = (sum2 & 0xffff) + (sum2 >> 16); |
||||
|
} |
||||
|
|
||||
|
// Second reduction step to reduce sums to 16 bits
|
||||
|
sum1 = (sum1 & 0xffff) + (sum1 >> 16); |
||||
|
sum2 = (sum2 & 0xffff) + (sum2 >> 16); |
||||
|
return(sum2 << 16 | sum1); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
// Implementation from Wikipedia
|
||||
|
// Slightly slower than Fletcher above, but slightly more reliable.
|
||||
|
#define MOD_ADLER 65521
|
||||
|
// data: Pointer to the data to be summed; len is in bytes
|
||||
|
u32 HashAdler32(const u8* data, size_t len) |
||||
|
{ |
||||
|
u32 a = 1, b = 0; |
||||
|
|
||||
|
while (len) |
||||
|
{ |
||||
|
size_t tlen = len > 5550 ? 5550 : len; |
||||
|
len -= tlen; |
||||
|
|
||||
|
do |
||||
|
{ |
||||
|
a += *data++; |
||||
|
b += a; |
||||
|
} |
||||
|
while (--tlen); |
||||
|
|
||||
|
a = (a & 0xffff) + (a >> 16) * (65536 - MOD_ADLER); |
||||
|
b = (b & 0xffff) + (b >> 16) * (65536 - MOD_ADLER); |
||||
|
} |
||||
|
|
||||
|
// It can be shown that a <= 0x1013a here, so a single subtract will do.
|
||||
|
if (a >= MOD_ADLER) |
||||
|
{ |
||||
|
a -= MOD_ADLER; |
||||
|
} |
||||
|
|
||||
|
// It can be shown that b can reach 0xfff87 here.
|
||||
|
b = (b & 0xffff) + (b >> 16) * (65536 - MOD_ADLER); |
||||
|
|
||||
|
if (b >= MOD_ADLER) |
||||
|
{ |
||||
|
b -= MOD_ADLER; |
||||
|
} |
||||
|
|
||||
|
return((b << 16) | a); |
||||
|
} |
||||
|
|
||||
|
// Stupid hash - but can't go back now :)
|
||||
|
// Don't use for new things. At least it's reasonably fast.
|
||||
|
u32 HashEctor(const u8* ptr, int length) |
||||
|
{ |
||||
|
u32 crc = 0; |
||||
|
|
||||
|
for (int i = 0; i < length; i++) |
||||
|
{ |
||||
|
crc ^= ptr[i]; |
||||
|
crc = (crc << 3) | (crc >> 29); |
||||
|
} |
||||
|
|
||||
|
return(crc); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
#ifdef _M_X64
|
||||
|
|
||||
|
//-----------------------------------------------------------------------------
|
||||
|
// Block read - if your platform needs to do endian-swapping or can only
|
||||
|
// handle aligned reads, do the conversion here
|
||||
|
|
||||
|
inline u64 getblock(const u64 * p, int i) |
||||
|
{ |
||||
|
return p[i]; |
||||
|
} |
||||
|
|
||||
|
//----------
|
||||
|
// Block mix - combine the key bits with the hash bits and scramble everything
|
||||
|
|
||||
|
inline void bmix64(u64 & h1, u64 & h2, u64 & k1, u64 & k2, u64 & c1, u64 & c2) |
||||
|
{ |
||||
|
k1 *= c1; |
||||
|
k1 = _rotl64(k1,23); |
||||
|
k1 *= c2; |
||||
|
h1 ^= k1; |
||||
|
h1 += h2; |
||||
|
|
||||
|
h2 = _rotl64(h2,41); |
||||
|
|
||||
|
k2 *= c2; |
||||
|
k2 = _rotl64(k2,23); |
||||
|
k2 *= c1; |
||||
|
h2 ^= k2; |
||||
|
h2 += h1; |
||||
|
|
||||
|
h1 = h1*3+0x52dce729; |
||||
|
h2 = h2*3+0x38495ab5; |
||||
|
|
||||
|
c1 = c1*5+0x7b7d159c; |
||||
|
c2 = c2*5+0x6bce6396; |
||||
|
} |
||||
|
|
||||
|
//----------
|
||||
|
// Finalization mix - avalanches all bits to within 0.05% bias
|
||||
|
|
||||
|
inline u64 fmix64(u64 k) |
||||
|
{ |
||||
|
k ^= k >> 33; |
||||
|
k *= 0xff51afd7ed558ccd; |
||||
|
k ^= k >> 33; |
||||
|
k *= 0xc4ceb9fe1a85ec53; |
||||
|
k ^= k >> 33; |
||||
|
|
||||
|
return k; |
||||
|
} |
||||
|
|
||||
|
u64 GetMurmurHash3(const u8 *src, int len, u32 samples) |
||||
|
{ |
||||
|
const u8 * data = (const u8*)src; |
||||
|
const int nblocks = len / 16; |
||||
|
u32 Step = (len / 8); |
||||
|
if(samples == 0) samples = max(Step, 1u); |
||||
|
Step = Step / samples; |
||||
|
if(Step < 1) Step = 1; |
||||
|
|
||||
|
u64 h1 = 0x9368e53c2f6af274; |
||||
|
u64 h2 = 0x586dcd208f7cd3fd; |
||||
|
|
||||
|
u64 c1 = 0x87c37b91114253d5; |
||||
|
u64 c2 = 0x4cf5ad432745937f; |
||||
|
|
||||
|
|
||||
|
//----------
|
||||
|
// body
|
||||
|
|
||||
|
const u64 * blocks = (const u64 *)(data); |
||||
|
|
||||
|
for(int i = 0; i < nblocks; i+=Step) |
||||
|
{ |
||||
|
u64 k1 = getblock(blocks,i*2+0); |
||||
|
u64 k2 = getblock(blocks,i*2+1); |
||||
|
|
||||
|
bmix64(h1,h2,k1,k2,c1,c2); |
||||
|
} |
||||
|
|
||||
|
//----------
|
||||
|
// tail
|
||||
|
|
||||
|
const u8 * tail = (const u8*)(data + nblocks*16); |
||||
|
|
||||
|
u64 k1 = 0; |
||||
|
u64 k2 = 0; |
||||
|
|
||||
|
switch(len & 15) |
||||
|
{ |
||||
|
case 15: k2 ^= u64(tail[14]) << 48; |
||||
|
case 14: k2 ^= u64(tail[13]) << 40; |
||||
|
case 13: k2 ^= u64(tail[12]) << 32; |
||||
|
case 12: k2 ^= u64(tail[11]) << 24; |
||||
|
case 11: k2 ^= u64(tail[10]) << 16; |
||||
|
case 10: k2 ^= u64(tail[ 9]) << 8; |
||||
|
case 9: k2 ^= u64(tail[ 8]) << 0; |
||||
|
|
||||
|
case 8: k1 ^= u64(tail[ 7]) << 56; |
||||
|
case 7: k1 ^= u64(tail[ 6]) << 48; |
||||
|
case 6: k1 ^= u64(tail[ 5]) << 40; |
||||
|
case 5: k1 ^= u64(tail[ 4]) << 32; |
||||
|
case 4: k1 ^= u64(tail[ 3]) << 24; |
||||
|
case 3: k1 ^= u64(tail[ 2]) << 16; |
||||
|
case 2: k1 ^= u64(tail[ 1]) << 8; |
||||
|
case 1: k1 ^= u64(tail[ 0]) << 0; |
||||
|
bmix64(h1,h2,k1,k2,c1,c2); |
||||
|
}; |
||||
|
|
||||
|
//----------
|
||||
|
// finalization
|
||||
|
|
||||
|
h2 ^= len; |
||||
|
|
||||
|
h1 += h2; |
||||
|
h2 += h1; |
||||
|
|
||||
|
h1 = fmix64(h1); |
||||
|
h2 = fmix64(h2); |
||||
|
|
||||
|
h1 += h2; |
||||
|
|
||||
|
return h1; |
||||
|
} |
||||
|
|
||||
|
|
||||
|
// CRC32 hash using the SSE4.2 instruction
|
||||
|
u64 GetCRC32(const u8 *src, int len, u32 samples) |
||||
|
{ |
||||
|
#if _M_SSE >= 0x402
|
||||
|
u64 h = len; |
||||
|
u32 Step = (len / 8); |
||||
|
const u64 *data = (const u64 *)src; |
||||
|
const u64 *end = data + Step; |
||||
|
if(samples == 0) samples = max(Step, 1u); |
||||
|
Step = Step / samples; |
||||
|
if(Step < 1) Step = 1; |
||||
|
while(data < end) |
||||
|
{ |
||||
|
h = _mm_crc32_u64(h, data[0]); |
||||
|
data += Step; |
||||
|
} |
||||
|
|
||||
|
const u8 *data2 = (const u8*)end; |
||||
|
return _mm_crc32_u64(h, u64(data2[0])); |
||||
|
#else
|
||||
|
return 0; |
||||
|
#endif
|
||||
|
} |
||||
|
|
||||
|
|
||||
|
/*
|
||||
|
* NOTE: This hash function is used for custom texture loading/dumping, so |
||||
|
* it should not be changed, which would require all custom textures to be |
||||
|
* recalculated for their new hash values. If the hashing function is |
||||
|
* changed, make sure this one is still used when the legacy parameter is |
||||
|
* true. |
||||
|
*/ |
||||
|
u64 GetHashHiresTexture(const u8 *src, int len, u32 samples) |
||||
|
{ |
||||
|
const u64 m = 0xc6a4a7935bd1e995; |
||||
|
u64 h = len * m; |
||||
|
const int r = 47; |
||||
|
u32 Step = (len / 8); |
||||
|
const u64 *data = (const u64 *)src; |
||||
|
const u64 *end = data + Step; |
||||
|
if(samples == 0) samples = max(Step, 1u); |
||||
|
Step = Step / samples; |
||||
|
if(Step < 1) Step = 1; |
||||
|
while(data < end) |
||||
|
{ |
||||
|
u64 k = data[0]; |
||||
|
data+=Step; |
||||
|
k *= m; |
||||
|
k ^= k >> r; |
||||
|
k *= m; |
||||
|
h ^= k; |
||||
|
h *= m; |
||||
|
} |
||||
|
|
||||
|
const u8 * data2 = (const u8*)end; |
||||
|
|
||||
|
switch(len & 7) |
||||
|
{ |
||||
|
case 7: h ^= u64(data2[6]) << 48; |
||||
|
case 6: h ^= u64(data2[5]) << 40; |
||||
|
case 5: h ^= u64(data2[4]) << 32; |
||||
|
case 4: h ^= u64(data2[3]) << 24; |
||||
|
case 3: h ^= u64(data2[2]) << 16; |
||||
|
case 2: h ^= u64(data2[1]) << 8; |
||||
|
case 1: h ^= u64(data2[0]); |
||||
|
h *= m; |
||||
|
}; |
||||
|
|
||||
|
h ^= h >> r; |
||||
|
h *= m; |
||||
|
h ^= h >> r; |
||||
|
|
||||
|
return h; |
||||
|
} |
||||
|
#else
|
||||
|
// CRC32 hash using the SSE4.2 instruction
|
||||
|
u64 GetCRC32(const u8 *src, int len, u32 samples) |
||||
|
{ |
||||
|
#if _M_SSE >= 0x402
|
||||
|
u32 h = len; |
||||
|
u32 Step = (len/4); |
||||
|
const u32 *data = (const u32 *)src; |
||||
|
const u32 *end = data + Step; |
||||
|
if(samples == 0) samples = max(Step, 1u); |
||||
|
Step = Step / samples; |
||||
|
if(Step < 1) Step = 1; |
||||
|
while(data < end) |
||||
|
{ |
||||
|
h = _mm_crc32_u32(h, data[0]); |
||||
|
data += Step; |
||||
|
} |
||||
|
|
||||
|
const u8 *data2 = (const u8*)end; |
||||
|
return (u64)_mm_crc32_u32(h, u32(data2[0])); |
||||
|
#else
|
||||
|
return 0; |
||||
|
#endif
|
||||
|
} |
||||
|
|
||||
|
//-----------------------------------------------------------------------------
|
||||
|
// Block read - if your platform needs to do endian-swapping or can only
|
||||
|
// handle aligned reads, do the conversion here
|
||||
|
|
||||
|
inline u32 getblock(const u32 * p, int i) |
||||
|
{ |
||||
|
return p[i]; |
||||
|
} |
||||
|
|
||||
|
//----------
|
||||
|
// Finalization mix - force all bits of a hash block to avalanche
|
||||
|
|
||||
|
// avalanches all bits to within 0.25% bias
|
||||
|
|
||||
|
inline u32 fmix32(u32 h) |
||||
|
{ |
||||
|
h ^= h >> 16; |
||||
|
h *= 0x85ebca6b; |
||||
|
h ^= h >> 13; |
||||
|
h *= 0xc2b2ae35; |
||||
|
h ^= h >> 16; |
||||
|
|
||||
|
return h; |
||||
|
} |
||||
|
|
||||
|
inline void bmix32(u32 & h1, u32 & h2, u32 & k1, u32 & k2, u32 & c1, u32 & c2) |
||||
|
{ |
||||
|
k1 *= c1; |
||||
|
k1 = _rotl(k1,11); |
||||
|
k1 *= c2; |
||||
|
h1 ^= k1; |
||||
|
h1 += h2; |
||||
|
|
||||
|
h2 = _rotl(h2,17); |
||||
|
|
||||
|
k2 *= c2; |
||||
|
k2 = _rotl(k2,11); |
||||
|
k2 *= c1; |
||||
|
h2 ^= k2; |
||||
|
h2 += h1; |
||||
|
|
||||
|
h1 = h1*3+0x52dce729; |
||||
|
h2 = h2*3+0x38495ab5; |
||||
|
|
||||
|
c1 = c1*5+0x7b7d159c; |
||||
|
c2 = c2*5+0x6bce6396; |
||||
|
} |
||||
|
|
||||
|
//----------
|
||||
|
|
||||
|
u64 GetMurmurHash3(const u8* src, int len, u32 samples) |
||||
|
{ |
||||
|
const u8 * data = (const u8*)src; |
||||
|
u32 out[2]; |
||||
|
const int nblocks = len / 8; |
||||
|
u32 Step = (len / 4); |
||||
|
if(samples == 0) samples = max(Step, 1u); |
||||
|
Step = Step / samples; |
||||
|
if(Step < 1) Step = 1; |
||||
|
|
||||
|
u32 h1 = 0x8de1c3ac; |
||||
|
u32 h2 = 0xbab98226; |
||||
|
|
||||
|
u32 c1 = 0x95543787; |
||||
|
u32 c2 = 0x2ad7eb25; |
||||
|
|
||||
|
//----------
|
||||
|
// body
|
||||
|
|
||||
|
const u32 * blocks = (const u32 *)(data + nblocks*8); |
||||
|
|
||||
|
for(int i = -nblocks; i < 0; i+=Step) |
||||
|
{ |
||||
|
u32 k1 = getblock(blocks,i*2+0); |
||||
|
u32 k2 = getblock(blocks,i*2+1); |
||||
|
|
||||
|
bmix32(h1,h2,k1,k2,c1,c2); |
||||
|
} |
||||
|
|
||||
|
//----------
|
||||
|
// tail
|
||||
|
|
||||
|
const u8 * tail = (const u8*)(data + nblocks*8); |
||||
|
|
||||
|
u32 k1 = 0; |
||||
|
u32 k2 = 0; |
||||
|
|
||||
|
switch(len & 7) |
||||
|
{ |
||||
|
case 7: k2 ^= tail[6] << 16; |
||||
|
case 6: k2 ^= tail[5] << 8; |
||||
|
case 5: k2 ^= tail[4] << 0; |
||||
|
case 4: k1 ^= tail[3] << 24; |
||||
|
case 3: k1 ^= tail[2] << 16; |
||||
|
case 2: k1 ^= tail[1] << 8; |
||||
|
case 1: k1 ^= tail[0] << 0; |
||||
|
bmix32(h1,h2,k1,k2,c1,c2); |
||||
|
}; |
||||
|
|
||||
|
//----------
|
||||
|
// finalization
|
||||
|
|
||||
|
h2 ^= len; |
||||
|
|
||||
|
h1 += h2; |
||||
|
h2 += h1; |
||||
|
|
||||
|
h1 = fmix32(h1); |
||||
|
h2 = fmix32(h2); |
||||
|
|
||||
|
h1 += h2; |
||||
|
h2 += h1; |
||||
|
|
||||
|
out[0] = h1; |
||||
|
out[1] = h2; |
||||
|
|
||||
|
return *((u64 *)&out); |
||||
|
} |
||||
|
|
||||
|
/*
|
||||
|
* FIXME: The old 32-bit version of this hash made different hashes than the |
||||
|
* 64-bit version. Until someone can make a new version of the 32-bit one that |
||||
|
* makes identical hashes, this is just a c/p of the 64-bit one. |
||||
|
*/ |
||||
|
u64 GetHashHiresTexture(const u8 *src, int len, u32 samples) |
||||
|
{ |
||||
|
const u64 m = 0xc6a4a7935bd1e995ULL; |
||||
|
u64 h = len * m; |
||||
|
const int r = 47; |
||||
|
u32 Step = (len / 8); |
||||
|
const u64 *data = (const u64 *)src; |
||||
|
const u64 *end = data + Step; |
||||
|
if(samples == 0) samples = max(Step, 1u); |
||||
|
Step = Step / samples; |
||||
|
if(Step < 1) Step = 1; |
||||
|
while(data < end) |
||||
|
{ |
||||
|
u64 k = data[0]; |
||||
|
data+=Step; |
||||
|
k *= m; |
||||
|
k ^= k >> r; |
||||
|
k *= m; |
||||
|
h ^= k; |
||||
|
h *= m; |
||||
|
} |
||||
|
|
||||
|
const u8 * data2 = (const u8*)end; |
||||
|
|
||||
|
switch(len & 7) |
||||
|
{ |
||||
|
case 7: h ^= u64(data2[6]) << 48; |
||||
|
case 6: h ^= u64(data2[5]) << 40; |
||||
|
case 5: h ^= u64(data2[4]) << 32; |
||||
|
case 4: h ^= u64(data2[3]) << 24; |
||||
|
case 3: h ^= u64(data2[2]) << 16; |
||||
|
case 2: h ^= u64(data2[1]) << 8; |
||||
|
case 1: h ^= u64(data2[0]); |
||||
|
h *= m; |
||||
|
}; |
||||
|
|
||||
|
h ^= h >> r; |
||||
|
h *= m; |
||||
|
h ^= h >> r; |
||||
|
|
||||
|
return h; |
||||
|
} |
||||
|
#endif
|
||||
|
|
||||
|
u64 GetHash64(const u8 *src, int len, u32 samples) |
||||
|
{ |
||||
|
return ptrHashFunction(src, len, samples); |
||||
|
} |
||||
|
|
||||
|
// sets the hash function used for the texture cache
|
||||
|
void SetHash64Function(bool useHiresTextures) |
||||
|
{ |
||||
|
if (useHiresTextures) |
||||
|
{ |
||||
|
ptrHashFunction = &GetHashHiresTexture; |
||||
|
} |
||||
|
#if _M_SSE >= 0x402
|
||||
|
else if (cpu_info.bSSE4_2 && !useHiresTextures) // sse crc32 version
|
||||
|
{ |
||||
|
ptrHashFunction = &GetCRC32; |
||||
|
} |
||||
|
#endif
|
||||
|
else |
||||
|
{ |
||||
|
ptrHashFunction = &GetMurmurHash3; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
|
||||
|
|
||||
@ -0,0 +1,20 @@ |
|||||
|
// Copyright 2013 Dolphin Emulator Project |
||||
|
// Licensed under GPLv2 |
||||
|
// Refer to the license.txt file included. |
||||
|
|
||||
|
|
||||
|
#ifndef _HASH_H_ |
||||
|
#define _HASH_H_ |
||||
|
|
||||
|
#include "common.h" |
||||
|
|
||||
|
u32 HashFletcher(const u8* data_u8, size_t length); // FAST. Length & 1 == 0. |
||||
|
u32 HashAdler32(const u8* data, size_t len); // Fairly accurate, slightly slower |
||||
|
u32 HashFNV(const u8* ptr, int length); // Another fast and decent hash |
||||
|
u32 HashEctor(const u8* ptr, int length); // JUNK. DO NOT USE FOR NEW THINGS |
||||
|
u64 GetCRC32(const u8 *src, int len, u32 samples); // SSE4.2 version of CRC32 |
||||
|
u64 GetHashHiresTexture(const u8 *src, int len, u32 samples); |
||||
|
u64 GetMurmurHash3(const u8 *src, int len, u32 samples); |
||||
|
u64 GetHash64(const u8 *src, int len, u32 samples); |
||||
|
void SetHash64Function(bool useHiresTextures); |
||||
|
#endif // _HASH_H_ |
||||
@ -0,0 +1,191 @@ |
|||||
|
// Copyright 2013 Dolphin Emulator Project |
||||
|
// Licensed under GPLv2 |
||||
|
// Refer to the license.txt file included. |
||||
|
|
||||
|
|
||||
|
#ifndef _LINEAR_DISKCACHE |
||||
|
#define _LINEAR_DISKCACHE |
||||
|
|
||||
|
#include "common.h" |
||||
|
#include <fstream> |
||||
|
|
||||
|
// defined in Version.cpp |
||||
|
extern const char *scm_rev_git_str; |
||||
|
|
||||
|
// On disk format: |
||||
|
//header{ |
||||
|
// u32 'DCAC'; |
||||
|
// u32 version; // svn_rev |
||||
|
// u16 sizeof(key_type); |
||||
|
// u16 sizeof(value_type); |
||||
|
//} |
||||
|
|
||||
|
//key_value_pair{ |
||||
|
// u32 value_size; |
||||
|
// key_type key; |
||||
|
// value_type[value_size] value; |
||||
|
//} |
||||
|
|
||||
|
template <typename K, typename V> |
||||
|
class LinearDiskCacheReader |
||||
|
{ |
||||
|
public: |
||||
|
virtual void Read(const K &key, const V *value, u32 value_size) = 0; |
||||
|
}; |
||||
|
|
||||
|
// Dead simple unsorted key-value store with append functionality. |
||||
|
// No random read functionality, all reading is done in OpenAndRead. |
||||
|
// Keys and values can contain any characters, including \0. |
||||
|
// |
||||
|
// Suitable for caching generated shader bytecode between executions. |
||||
|
// Not tuned for extreme performance but should be reasonably fast. |
||||
|
// Does not support keys or values larger than 2GB, which should be reasonable. |
||||
|
// Keys must have non-zero length; values can have zero length. |
||||
|
|
||||
|
// K and V are some POD type |
||||
|
// K : the key type |
||||
|
// V : value array type |
||||
|
template <typename K, typename V> |
||||
|
class LinearDiskCache |
||||
|
{ |
||||
|
public: |
||||
|
// return number of read entries |
||||
|
u32 OpenAndRead(const char *filename, LinearDiskCacheReader<K, V> &reader) |
||||
|
{ |
||||
|
using std::ios_base; |
||||
|
|
||||
|
// close any currently opened file |
||||
|
Close(); |
||||
|
m_num_entries = 0; |
||||
|
|
||||
|
// try opening for reading/writing |
||||
|
OpenFStream(m_file, filename, ios_base::in | ios_base::out | ios_base::binary); |
||||
|
|
||||
|
m_file.seekg(0, std::ios::end); |
||||
|
std::fstream::pos_type end_pos = m_file.tellg(); |
||||
|
m_file.seekg(0, std::ios::beg); |
||||
|
std::fstream::pos_type start_pos = m_file.tellg(); |
||||
|
std::streamoff file_size = end_pos - start_pos; |
||||
|
|
||||
|
if (m_file.is_open() && ValidateHeader()) |
||||
|
{ |
||||
|
// good header, read some key/value pairs |
||||
|
K key; |
||||
|
|
||||
|
V *value = NULL; |
||||
|
u32 value_size; |
||||
|
u32 entry_number; |
||||
|
|
||||
|
std::fstream::pos_type last_pos = m_file.tellg(); |
||||
|
|
||||
|
while (Read(&value_size)) |
||||
|
{ |
||||
|
std::streamoff next_extent = (last_pos - start_pos) + sizeof(value_size) + value_size; |
||||
|
if (next_extent > file_size) |
||||
|
break; |
||||
|
|
||||
|
delete[] value; |
||||
|
value = new V[value_size]; |
||||
|
|
||||
|
// read key/value and pass to reader |
||||
|
if (Read(&key) && |
||||
|
Read(value, value_size) && |
||||
|
Read(&entry_number) && |
||||
|
entry_number == m_num_entries+1) |
||||
|
{ |
||||
|
reader.Read(key, value, value_size); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
break; |
||||
|
} |
||||
|
|
||||
|
m_num_entries++; |
||||
|
last_pos = m_file.tellg(); |
||||
|
} |
||||
|
m_file.seekp(last_pos); |
||||
|
m_file.clear(); |
||||
|
|
||||
|
delete[] value; |
||||
|
return m_num_entries; |
||||
|
} |
||||
|
|
||||
|
// failed to open file for reading or bad header |
||||
|
// close and recreate file |
||||
|
Close(); |
||||
|
m_file.open(filename, ios_base::out | ios_base::trunc | ios_base::binary); |
||||
|
WriteHeader(); |
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
|
void Sync() |
||||
|
{ |
||||
|
m_file.flush(); |
||||
|
} |
||||
|
|
||||
|
void Close() |
||||
|
{ |
||||
|
if (m_file.is_open()) |
||||
|
m_file.close(); |
||||
|
// clear any error flags |
||||
|
m_file.clear(); |
||||
|
} |
||||
|
|
||||
|
// Appends a key-value pair to the store. |
||||
|
void Append(const K &key, const V *value, u32 value_size) |
||||
|
{ |
||||
|
// TODO: Should do a check that we don't already have "key"? (I think each caller does that already.) |
||||
|
Write(&value_size); |
||||
|
Write(&key); |
||||
|
Write(value, value_size); |
||||
|
m_num_entries++; |
||||
|
Write(&m_num_entries); |
||||
|
} |
||||
|
|
||||
|
private: |
||||
|
void WriteHeader() |
||||
|
{ |
||||
|
Write(&m_header); |
||||
|
} |
||||
|
|
||||
|
bool ValidateHeader() |
||||
|
{ |
||||
|
char file_header[sizeof(Header)]; |
||||
|
|
||||
|
return (Read(file_header, sizeof(Header)) |
||||
|
&& !memcmp((const char*)&m_header, file_header, sizeof(Header))); |
||||
|
} |
||||
|
|
||||
|
template <typename D> |
||||
|
bool Write(const D *data, u32 count = 1) |
||||
|
{ |
||||
|
return m_file.write((const char*)data, count * sizeof(D)).good(); |
||||
|
} |
||||
|
|
||||
|
template <typename D> |
||||
|
bool Read(const D *data, u32 count = 1) |
||||
|
{ |
||||
|
return m_file.read((char*)data, count * sizeof(D)).good(); |
||||
|
} |
||||
|
|
||||
|
struct Header |
||||
|
{ |
||||
|
Header() |
||||
|
: id(*(u32*)"DCAC") |
||||
|
, key_t_size(sizeof(K)) |
||||
|
, value_t_size(sizeof(V)) |
||||
|
{ |
||||
|
memcpy(ver, scm_rev_git_str, 40); |
||||
|
} |
||||
|
|
||||
|
const u32 id; |
||||
|
const u16 key_t_size, value_t_size; |
||||
|
char ver[40]; |
||||
|
|
||||
|
} m_header; |
||||
|
|
||||
|
std::fstream m_file; |
||||
|
u32 m_num_entries; |
||||
|
}; |
||||
|
|
||||
|
#endif // _LINEAR_DISKCACHE |
||||
@ -0,0 +1,155 @@ |
|||||
|
// Copyright 2013 Dolphin Emulator Project |
||||
|
// Licensed under GPLv2 |
||||
|
// Refer to the license.txt file included. |
||||
|
|
||||
|
#ifndef _LOG_H_ |
||||
|
#define _LOG_H_ |
||||
|
|
||||
|
#define NOTICE_LEVEL 1 // VERY important information that is NOT errors. Like startup and OSReports. |
||||
|
#define ERROR_LEVEL 2 // Critical errors |
||||
|
#define WARNING_LEVEL 3 // Something is suspicious. |
||||
|
#define INFO_LEVEL 4 // General information. |
||||
|
#define DEBUG_LEVEL 5 // Detailed debugging - might make things slow. |
||||
|
|
||||
|
namespace LogTypes |
||||
|
{ |
||||
|
|
||||
|
enum LOG_TYPE { |
||||
|
ACTIONREPLAY, |
||||
|
AUDIO, |
||||
|
AUDIO_INTERFACE, |
||||
|
BOOT, |
||||
|
COMMANDPROCESSOR, |
||||
|
COMMON, |
||||
|
CONSOLE, |
||||
|
DISCIO, |
||||
|
FILEMON, |
||||
|
DSPHLE, |
||||
|
DSPLLE, |
||||
|
DSP_MAIL, |
||||
|
DSPINTERFACE, |
||||
|
DVDINTERFACE, |
||||
|
DYNA_REC, |
||||
|
EXPANSIONINTERFACE, |
||||
|
GDB_STUB, |
||||
|
POWERPC, |
||||
|
GPFIFO, |
||||
|
OSHLE, |
||||
|
MASTER_LOG, |
||||
|
MEMMAP, |
||||
|
MEMCARD_MANAGER, |
||||
|
OSREPORT, |
||||
|
PAD, |
||||
|
PROCESSORINTERFACE, |
||||
|
PIXELENGINE, |
||||
|
SERIALINTERFACE, |
||||
|
SP1, |
||||
|
STREAMINGINTERFACE, |
||||
|
VIDEO, |
||||
|
VIDEOINTERFACE, |
||||
|
WII_IOB, |
||||
|
WII_IPC, |
||||
|
WII_IPC_DVD, |
||||
|
WII_IPC_ES, |
||||
|
WII_IPC_FILEIO, |
||||
|
WII_IPC_HID, |
||||
|
WII_IPC_HLE, |
||||
|
WII_IPC_NET, |
||||
|
WII_IPC_WC24, |
||||
|
WII_IPC_SSL, |
||||
|
WII_IPC_SD, |
||||
|
WII_IPC_STM, |
||||
|
WII_IPC_WIIMOTE, |
||||
|
WIIMOTE, |
||||
|
NETPLAY, |
||||
|
|
||||
|
NUMBER_OF_LOGS // Must be last |
||||
|
}; |
||||
|
|
||||
|
// FIXME: should this be removed? |
||||
|
enum LOG_LEVELS { |
||||
|
LNOTICE = NOTICE_LEVEL, |
||||
|
LERROR = ERROR_LEVEL, |
||||
|
LWARNING = WARNING_LEVEL, |
||||
|
LINFO = INFO_LEVEL, |
||||
|
LDEBUG = DEBUG_LEVEL, |
||||
|
}; |
||||
|
|
||||
|
#define LOGTYPES_LEVELS LogTypes::LOG_LEVELS |
||||
|
#define LOGTYPES_TYPE LogTypes::LOG_TYPE |
||||
|
|
||||
|
} // namespace |
||||
|
|
||||
|
void GenericLog(LOGTYPES_LEVELS level, LOGTYPES_TYPE type, |
||||
|
const char *file, int line, const char *fmt, ...) |
||||
|
#ifdef __GNUC__ |
||||
|
__attribute__((format(printf, 5, 6))) |
||||
|
#endif |
||||
|
; |
||||
|
|
||||
|
#if defined LOGGING || defined _DEBUG || defined DEBUGFAST |
||||
|
#define MAX_LOGLEVEL DEBUG_LEVEL |
||||
|
#else |
||||
|
#ifndef MAX_LOGLEVEL |
||||
|
#define MAX_LOGLEVEL WARNING_LEVEL |
||||
|
#endif // loglevel |
||||
|
#endif // logging |
||||
|
|
||||
|
#ifdef GEKKO |
||||
|
#define GENERIC_LOG(t, v, ...) |
||||
|
#else |
||||
|
// Let the compiler optimize this out |
||||
|
#define GENERIC_LOG(t, v, ...) { \ |
||||
|
if (v <= MAX_LOGLEVEL) \ |
||||
|
GenericLog(v, t, __FILE__, __LINE__, __VA_ARGS__); \ |
||||
|
} |
||||
|
#endif |
||||
|
|
||||
|
#define ERROR_LOG(t,...) do { GENERIC_LOG(LogTypes::t, LogTypes::LERROR, __VA_ARGS__) } while (0) |
||||
|
#define WARN_LOG(t,...) do { GENERIC_LOG(LogTypes::t, LogTypes::LWARNING, __VA_ARGS__) } while (0) |
||||
|
#define NOTICE_LOG(t,...) do { GENERIC_LOG(LogTypes::t, LogTypes::LNOTICE, __VA_ARGS__) } while (0) |
||||
|
#define INFO_LOG(t,...) do { GENERIC_LOG(LogTypes::t, LogTypes::LINFO, __VA_ARGS__) } while (0) |
||||
|
#define DEBUG_LOG(t,...) do { GENERIC_LOG(LogTypes::t, LogTypes::LDEBUG, __VA_ARGS__) } while (0) |
||||
|
|
||||
|
#if MAX_LOGLEVEL >= DEBUG_LEVEL |
||||
|
#define _dbg_assert_(_t_, _a_) \ |
||||
|
if (!(_a_)) {\ |
||||
|
ERROR_LOG(_t_, "Error...\n\n Line: %d\n File: %s\n Time: %s\n\nIgnore and continue?", \ |
||||
|
__LINE__, __FILE__, __TIME__); \ |
||||
|
if (!PanicYesNo("*** Assertion (see log)***\n")) {Crash();} \ |
||||
|
} |
||||
|
#define _dbg_assert_msg_(_t_, _a_, ...)\ |
||||
|
if (!(_a_)) {\ |
||||
|
ERROR_LOG(_t_, __VA_ARGS__); \ |
||||
|
if (!PanicYesNo(__VA_ARGS__)) {Crash();} \ |
||||
|
} |
||||
|
#define _dbg_update_() Host_UpdateLogDisplay(); |
||||
|
|
||||
|
#else // not debug |
||||
|
#define _dbg_update_() ; |
||||
|
|
||||
|
#ifndef _dbg_assert_ |
||||
|
#define _dbg_assert_(_t_, _a_) {} |
||||
|
#define _dbg_assert_msg_(_t_, _a_, _desc_, ...) {} |
||||
|
#endif // dbg_assert |
||||
|
#endif // MAX_LOGLEVEL DEBUG |
||||
|
|
||||
|
#define _assert_(_a_) _dbg_assert_(MASTER_LOG, _a_) |
||||
|
|
||||
|
#ifndef GEKKO |
||||
|
#ifdef _WIN32 |
||||
|
#define _assert_msg_(_t_, _a_, _fmt_, ...) \ |
||||
|
if (!(_a_)) {\ |
||||
|
if (!PanicYesNo(_fmt_, __VA_ARGS__)) {Crash();} \ |
||||
|
} |
||||
|
#else // not win32 |
||||
|
#define _assert_msg_(_t_, _a_, _fmt_, ...) \ |
||||
|
if (!(_a_)) {\ |
||||
|
if (!PanicYesNo(_fmt_, ##__VA_ARGS__)) {Crash();} \ |
||||
|
} |
||||
|
#endif // WIN32 |
||||
|
#else // GEKKO |
||||
|
#define _assert_msg_(_t_, _a_, _fmt_, ...) |
||||
|
#endif |
||||
|
|
||||
|
#endif // _LOG_H_ |
||||
@ -0,0 +1,199 @@ |
|||||
|
// Copyright 2013 Dolphin Emulator Project
|
||||
|
// Licensed under GPLv2
|
||||
|
// Refer to the license.txt file included.
|
||||
|
|
||||
|
#include <algorithm>
|
||||
|
|
||||
|
#ifdef ANDROID
|
||||
|
#include "Host.h"
|
||||
|
#endif
|
||||
|
#include "log_manager.h"
|
||||
|
#include "console_listener.h"
|
||||
|
#include "timer.h"
|
||||
|
#include "thread.h"
|
||||
|
#include "file_util.h"
|
||||
|
|
||||
|
void GenericLog(LogTypes::LOG_LEVELS level, LogTypes::LOG_TYPE type, |
||||
|
const char *file, int line, const char* fmt, ...) |
||||
|
{ |
||||
|
va_list args; |
||||
|
va_start(args, fmt); |
||||
|
if (LogManager::GetInstance()) |
||||
|
LogManager::GetInstance()->Log(level, type, |
||||
|
file, line, fmt, args); |
||||
|
va_end(args); |
||||
|
} |
||||
|
|
||||
|
LogManager *LogManager::m_logManager = NULL; |
||||
|
|
||||
|
LogManager::LogManager() |
||||
|
{ |
||||
|
// create log files
|
||||
|
m_Log[LogTypes::MASTER_LOG] = new LogContainer("*", "Master Log"); |
||||
|
m_Log[LogTypes::BOOT] = new LogContainer("BOOT", "Boot"); |
||||
|
m_Log[LogTypes::COMMON] = new LogContainer("COMMON", "Common"); |
||||
|
m_Log[LogTypes::DISCIO] = new LogContainer("DIO", "Disc IO"); |
||||
|
m_Log[LogTypes::FILEMON] = new LogContainer("FileMon", "File Monitor"); |
||||
|
m_Log[LogTypes::PAD] = new LogContainer("PAD", "Pad"); |
||||
|
m_Log[LogTypes::PIXELENGINE] = new LogContainer("PE", "PixelEngine"); |
||||
|
m_Log[LogTypes::COMMANDPROCESSOR] = new LogContainer("CP", "CommandProc"); |
||||
|
m_Log[LogTypes::VIDEOINTERFACE] = new LogContainer("VI", "VideoInt"); |
||||
|
m_Log[LogTypes::SERIALINTERFACE] = new LogContainer("SI", "SerialInt"); |
||||
|
m_Log[LogTypes::PROCESSORINTERFACE] = new LogContainer("PI", "ProcessorInt"); |
||||
|
m_Log[LogTypes::MEMMAP] = new LogContainer("MI", "MI & memmap"); |
||||
|
m_Log[LogTypes::SP1] = new LogContainer("SP1", "Serial Port 1"); |
||||
|
m_Log[LogTypes::STREAMINGINTERFACE] = new LogContainer("Stream", "StreamingInt"); |
||||
|
m_Log[LogTypes::DSPINTERFACE] = new LogContainer("DSP", "DSPInterface"); |
||||
|
m_Log[LogTypes::DVDINTERFACE] = new LogContainer("DVD", "DVDInterface"); |
||||
|
m_Log[LogTypes::GPFIFO] = new LogContainer("GP", "GPFifo"); |
||||
|
m_Log[LogTypes::EXPANSIONINTERFACE] = new LogContainer("EXI", "ExpansionInt"); |
||||
|
m_Log[LogTypes::GDB_STUB] = new LogContainer("GDB_STUB", "GDB Stub"); |
||||
|
m_Log[LogTypes::AUDIO_INTERFACE] = new LogContainer("AI", "AudioInt"); |
||||
|
m_Log[LogTypes::POWERPC] = new LogContainer("PowerPC", "IBM CPU"); |
||||
|
m_Log[LogTypes::OSHLE] = new LogContainer("HLE", "HLE"); |
||||
|
m_Log[LogTypes::DSPHLE] = new LogContainer("DSPHLE", "DSP HLE"); |
||||
|
m_Log[LogTypes::DSPLLE] = new LogContainer("DSPLLE", "DSP LLE"); |
||||
|
m_Log[LogTypes::DSP_MAIL] = new LogContainer("DSPMails", "DSP Mails"); |
||||
|
m_Log[LogTypes::VIDEO] = new LogContainer("Video", "Video Backend"); |
||||
|
m_Log[LogTypes::AUDIO] = new LogContainer("Audio", "Audio Emulator"); |
||||
|
m_Log[LogTypes::DYNA_REC] = new LogContainer("JIT", "Dynamic Recompiler"); |
||||
|
m_Log[LogTypes::CONSOLE] = new LogContainer("CONSOLE", "Dolphin Console"); |
||||
|
m_Log[LogTypes::OSREPORT] = new LogContainer("OSREPORT", "OSReport"); |
||||
|
m_Log[LogTypes::WIIMOTE] = new LogContainer("Wiimote", "Wiimote"); |
||||
|
m_Log[LogTypes::WII_IOB] = new LogContainer("WII_IOB", "WII IO Bridge"); |
||||
|
m_Log[LogTypes::WII_IPC] = new LogContainer("WII_IPC", "WII IPC"); |
||||
|
m_Log[LogTypes::WII_IPC_HID] = new LogContainer("WII_IPC_HID", "WII IPC HID"); |
||||
|
m_Log[LogTypes::WII_IPC_HLE] = new LogContainer("WII_IPC_HLE", "WII IPC HLE"); |
||||
|
m_Log[LogTypes::WII_IPC_DVD] = new LogContainer("WII_IPC_DVD", "WII IPC DVD"); |
||||
|
m_Log[LogTypes::WII_IPC_ES] = new LogContainer("WII_IPC_ES", "WII IPC ES"); |
||||
|
m_Log[LogTypes::WII_IPC_FILEIO] = new LogContainer("WII_IPC_FILEIO","WII IPC FILEIO"); |
||||
|
m_Log[LogTypes::WII_IPC_SD] = new LogContainer("WII_IPC_SD", "WII IPC SD"); |
||||
|
m_Log[LogTypes::WII_IPC_STM] = new LogContainer("WII_IPC_STM", "WII IPC STM"); |
||||
|
m_Log[LogTypes::WII_IPC_NET] = new LogContainer("WII_IPC_NET", "WII IPC NET"); |
||||
|
m_Log[LogTypes::WII_IPC_WC24] = new LogContainer("WII_IPC_WC24", "WII IPC WC24"); |
||||
|
m_Log[LogTypes::WII_IPC_SSL] = new LogContainer("WII_IPC_SSL", "WII IPC SSL"); |
||||
|
m_Log[LogTypes::WII_IPC_WIIMOTE] = new LogContainer("WII_IPC_WIIMOTE","WII IPC WIIMOTE"); |
||||
|
m_Log[LogTypes::ACTIONREPLAY] = new LogContainer("ActionReplay", "ActionReplay"); |
||||
|
m_Log[LogTypes::MEMCARD_MANAGER] = new LogContainer("MemCard Manager", "MemCard Manager"); |
||||
|
m_Log[LogTypes::NETPLAY] = new LogContainer("NETPLAY", "Netplay"); |
||||
|
|
||||
|
m_fileLog = new FileLogListener(File::GetUserPath(F_MAINLOG_IDX).c_str()); |
||||
|
m_consoleLog = new ConsoleListener(); |
||||
|
m_debuggerLog = new DebuggerLogListener(); |
||||
|
|
||||
|
for (int i = 0; i < LogTypes::NUMBER_OF_LOGS; ++i) |
||||
|
{ |
||||
|
m_Log[i]->SetEnable(true); |
||||
|
m_Log[i]->AddListener(m_fileLog); |
||||
|
m_Log[i]->AddListener(m_consoleLog); |
||||
|
#ifdef _MSC_VER
|
||||
|
if (IsDebuggerPresent()) |
||||
|
m_Log[i]->AddListener(m_debuggerLog); |
||||
|
#endif
|
||||
|
} |
||||
|
} |
||||
|
|
||||
|
LogManager::~LogManager() |
||||
|
{ |
||||
|
for (int i = 0; i < LogTypes::NUMBER_OF_LOGS; ++i) |
||||
|
{ |
||||
|
m_logManager->RemoveListener((LogTypes::LOG_TYPE)i, m_fileLog); |
||||
|
m_logManager->RemoveListener((LogTypes::LOG_TYPE)i, m_consoleLog); |
||||
|
m_logManager->RemoveListener((LogTypes::LOG_TYPE)i, m_debuggerLog); |
||||
|
} |
||||
|
|
||||
|
for (int i = 0; i < LogTypes::NUMBER_OF_LOGS; ++i) |
||||
|
delete m_Log[i]; |
||||
|
|
||||
|
delete m_fileLog; |
||||
|
delete m_consoleLog; |
||||
|
delete m_debuggerLog; |
||||
|
} |
||||
|
|
||||
|
void LogManager::Log(LogTypes::LOG_LEVELS level, LogTypes::LOG_TYPE type, |
||||
|
const char *file, int line, const char *format, va_list args) |
||||
|
{ |
||||
|
char temp[MAX_MSGLEN]; |
||||
|
char msg[MAX_MSGLEN * 2]; |
||||
|
LogContainer *log = m_Log[type]; |
||||
|
|
||||
|
if (!log->IsEnabled() || level > log->GetLevel() || ! log->HasListeners()) |
||||
|
return; |
||||
|
|
||||
|
CharArrayFromFormatV(temp, MAX_MSGLEN, format, args); |
||||
|
|
||||
|
static const char level_to_char[7] = "-NEWID"; |
||||
|
sprintf(msg, "%s %s:%u %c[%s]: %s\n", |
||||
|
Common::Timer::GetTimeFormatted().c_str(), |
||||
|
file, line, level_to_char[(int)level], |
||||
|
log->GetShortName(), temp); |
||||
|
#ifdef ANDROID
|
||||
|
Host_SysMessage(msg); |
||||
|
#endif
|
||||
|
log->Trigger(level, msg); |
||||
|
} |
||||
|
|
||||
|
void LogManager::Init() |
||||
|
{ |
||||
|
m_logManager = new LogManager(); |
||||
|
} |
||||
|
|
||||
|
void LogManager::Shutdown() |
||||
|
{ |
||||
|
delete m_logManager; |
||||
|
m_logManager = NULL; |
||||
|
} |
||||
|
|
||||
|
LogContainer::LogContainer(const char* shortName, const char* fullName, bool enable) |
||||
|
: m_enable(enable) |
||||
|
{ |
||||
|
strncpy(m_fullName, fullName, 128); |
||||
|
strncpy(m_shortName, shortName, 32); |
||||
|
m_level = LogTypes::LWARNING; |
||||
|
} |
||||
|
|
||||
|
// LogContainer
|
||||
|
void LogContainer::AddListener(LogListener *listener) |
||||
|
{ |
||||
|
std::lock_guard<std::mutex> lk(m_listeners_lock); |
||||
|
m_listeners.insert(listener); |
||||
|
} |
||||
|
|
||||
|
void LogContainer::RemoveListener(LogListener *listener) |
||||
|
{ |
||||
|
std::lock_guard<std::mutex> lk(m_listeners_lock); |
||||
|
m_listeners.erase(listener); |
||||
|
} |
||||
|
|
||||
|
void LogContainer::Trigger(LogTypes::LOG_LEVELS level, const char *msg) |
||||
|
{ |
||||
|
std::lock_guard<std::mutex> lk(m_listeners_lock); |
||||
|
|
||||
|
std::set<LogListener*>::const_iterator i; |
||||
|
for (i = m_listeners.begin(); i != m_listeners.end(); ++i) |
||||
|
{ |
||||
|
(*i)->Log(level, msg); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
FileLogListener::FileLogListener(const char *filename) |
||||
|
{ |
||||
|
OpenFStream(m_logfile, filename, std::ios::app); |
||||
|
SetEnable(true); |
||||
|
} |
||||
|
|
||||
|
void FileLogListener::Log(LogTypes::LOG_LEVELS, const char *msg) |
||||
|
{ |
||||
|
if (!IsEnabled() || !IsValid()) |
||||
|
return; |
||||
|
|
||||
|
std::lock_guard<std::mutex> lk(m_log_lock); |
||||
|
m_logfile << msg << std::flush; |
||||
|
} |
||||
|
|
||||
|
void DebuggerLogListener::Log(LogTypes::LOG_LEVELS, const char *msg) |
||||
|
{ |
||||
|
#if _MSC_VER
|
||||
|
::OutputDebugStringA(msg); |
||||
|
#endif
|
||||
|
} |
||||
@ -0,0 +1,169 @@ |
|||||
|
// Copyright 2013 Dolphin Emulator Project |
||||
|
// Licensed under GPLv2 |
||||
|
// Refer to the license.txt file included. |
||||
|
|
||||
|
#ifndef _LOGMANAGER_H_ |
||||
|
#define _LOGMANAGER_H_ |
||||
|
|
||||
|
#include "log.h" |
||||
|
#include "string_util.h" |
||||
|
#include "thread.h" |
||||
|
#include "file_util.h" |
||||
|
|
||||
|
#include <set> |
||||
|
#include <string.h> |
||||
|
|
||||
|
#define MAX_MESSAGES 8000 |
||||
|
#define MAX_MSGLEN 1024 |
||||
|
|
||||
|
|
||||
|
// pure virtual interface |
||||
|
class LogListener |
||||
|
{ |
||||
|
public: |
||||
|
virtual ~LogListener() {} |
||||
|
|
||||
|
virtual void Log(LogTypes::LOG_LEVELS, const char *msg) = 0; |
||||
|
}; |
||||
|
|
||||
|
class FileLogListener : public LogListener |
||||
|
{ |
||||
|
public: |
||||
|
FileLogListener(const char *filename); |
||||
|
|
||||
|
void Log(LogTypes::LOG_LEVELS, const char *msg); |
||||
|
|
||||
|
bool IsValid() { return !m_logfile.fail(); } |
||||
|
bool IsEnabled() const { return m_enable; } |
||||
|
void SetEnable(bool enable) { m_enable = enable; } |
||||
|
|
||||
|
const char* GetName() const { return "file"; } |
||||
|
|
||||
|
private: |
||||
|
std::mutex m_log_lock; |
||||
|
std::ofstream m_logfile; |
||||
|
bool m_enable; |
||||
|
}; |
||||
|
|
||||
|
class DebuggerLogListener : public LogListener |
||||
|
{ |
||||
|
public: |
||||
|
void Log(LogTypes::LOG_LEVELS, const char *msg); |
||||
|
}; |
||||
|
|
||||
|
class LogContainer |
||||
|
{ |
||||
|
public: |
||||
|
LogContainer(const char* shortName, const char* fullName, bool enable = false); |
||||
|
|
||||
|
const char* GetShortName() const { return m_shortName; } |
||||
|
const char* GetFullName() const { return m_fullName; } |
||||
|
|
||||
|
void AddListener(LogListener* listener); |
||||
|
void RemoveListener(LogListener* listener); |
||||
|
|
||||
|
void Trigger(LogTypes::LOG_LEVELS, const char *msg); |
||||
|
|
||||
|
bool IsEnabled() const { return m_enable; } |
||||
|
void SetEnable(bool enable) { m_enable = enable; } |
||||
|
|
||||
|
LogTypes::LOG_LEVELS GetLevel() const { return m_level; } |
||||
|
|
||||
|
void SetLevel(LogTypes::LOG_LEVELS level) { m_level = level; } |
||||
|
|
||||
|
bool HasListeners() const { return !m_listeners.empty(); } |
||||
|
|
||||
|
private: |
||||
|
char m_fullName[128]; |
||||
|
char m_shortName[32]; |
||||
|
bool m_enable; |
||||
|
LogTypes::LOG_LEVELS m_level; |
||||
|
std::mutex m_listeners_lock; |
||||
|
std::set<LogListener*> m_listeners; |
||||
|
}; |
||||
|
|
||||
|
class ConsoleListener; |
||||
|
|
||||
|
class LogManager : NonCopyable |
||||
|
{ |
||||
|
private: |
||||
|
LogContainer* m_Log[LogTypes::NUMBER_OF_LOGS]; |
||||
|
FileLogListener *m_fileLog; |
||||
|
ConsoleListener *m_consoleLog; |
||||
|
DebuggerLogListener *m_debuggerLog; |
||||
|
static LogManager *m_logManager; // Singleton. Ugh. |
||||
|
|
||||
|
LogManager(); |
||||
|
~LogManager(); |
||||
|
public: |
||||
|
|
||||
|
static u32 GetMaxLevel() { return MAX_LOGLEVEL; } |
||||
|
|
||||
|
void Log(LogTypes::LOG_LEVELS level, LogTypes::LOG_TYPE type, |
||||
|
const char *file, int line, const char *fmt, va_list args); |
||||
|
|
||||
|
void SetLogLevel(LogTypes::LOG_TYPE type, LogTypes::LOG_LEVELS level) |
||||
|
{ |
||||
|
m_Log[type]->SetLevel(level); |
||||
|
} |
||||
|
|
||||
|
void SetEnable(LogTypes::LOG_TYPE type, bool enable) |
||||
|
{ |
||||
|
m_Log[type]->SetEnable(enable); |
||||
|
} |
||||
|
|
||||
|
bool IsEnabled(LogTypes::LOG_TYPE type) const |
||||
|
{ |
||||
|
return m_Log[type]->IsEnabled(); |
||||
|
} |
||||
|
|
||||
|
const char* GetShortName(LogTypes::LOG_TYPE type) const |
||||
|
{ |
||||
|
return m_Log[type]->GetShortName(); |
||||
|
} |
||||
|
|
||||
|
const char* GetFullName(LogTypes::LOG_TYPE type) const |
||||
|
{ |
||||
|
return m_Log[type]->GetFullName(); |
||||
|
} |
||||
|
|
||||
|
void AddListener(LogTypes::LOG_TYPE type, LogListener *listener) |
||||
|
{ |
||||
|
m_Log[type]->AddListener(listener); |
||||
|
} |
||||
|
|
||||
|
void RemoveListener(LogTypes::LOG_TYPE type, LogListener *listener) |
||||
|
{ |
||||
|
m_Log[type]->RemoveListener(listener); |
||||
|
} |
||||
|
|
||||
|
FileLogListener *GetFileListener() const |
||||
|
{ |
||||
|
return m_fileLog; |
||||
|
} |
||||
|
|
||||
|
ConsoleListener *GetConsoleListener() const |
||||
|
{ |
||||
|
return m_consoleLog; |
||||
|
} |
||||
|
|
||||
|
DebuggerLogListener *GetDebuggerListener() const |
||||
|
{ |
||||
|
return m_debuggerLog; |
||||
|
} |
||||
|
|
||||
|
static LogManager* GetInstance() |
||||
|
{ |
||||
|
return m_logManager; |
||||
|
} |
||||
|
|
||||
|
static void SetInstance(LogManager *logManager) |
||||
|
{ |
||||
|
m_logManager = logManager; |
||||
|
} |
||||
|
|
||||
|
static void Init(); |
||||
|
static void Shutdown(); |
||||
|
}; |
||||
|
|
||||
|
#endif // _LOGMANAGER_H_ |
||||
@ -0,0 +1,212 @@ |
|||||
|
// Copyright 2013 Dolphin Emulator Project
|
||||
|
// Licensed under GPLv2
|
||||
|
// Refer to the license.txt file included.
|
||||
|
|
||||
|
|
||||
|
#include "common.h"
|
||||
|
#include "math_util.h"
|
||||
|
|
||||
|
#include <cmath>
|
||||
|
#include <numeric>
|
||||
|
|
||||
|
namespace MathUtil |
||||
|
{ |
||||
|
|
||||
|
u32 ClassifyDouble(double dvalue) |
||||
|
{ |
||||
|
// TODO: Optimize the below to be as fast as possible.
|
||||
|
IntDouble value; |
||||
|
value.d = dvalue; |
||||
|
u64 sign = value.i & DOUBLE_SIGN; |
||||
|
u64 exp = value.i & DOUBLE_EXP; |
||||
|
if (exp > DOUBLE_ZERO && exp < DOUBLE_EXP) |
||||
|
{ |
||||
|
// Nice normalized number.
|
||||
|
return sign ? PPC_FPCLASS_NN : PPC_FPCLASS_PN; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
u64 mantissa = value.i & DOUBLE_FRAC; |
||||
|
if (mantissa) |
||||
|
{ |
||||
|
if (exp) |
||||
|
{ |
||||
|
return PPC_FPCLASS_QNAN; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
// Denormalized number.
|
||||
|
return sign ? PPC_FPCLASS_ND : PPC_FPCLASS_PD; |
||||
|
} |
||||
|
} |
||||
|
else if (exp) |
||||
|
{ |
||||
|
//Infinite
|
||||
|
return sign ? PPC_FPCLASS_NINF : PPC_FPCLASS_PINF; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
//Zero
|
||||
|
return sign ? PPC_FPCLASS_NZ : PPC_FPCLASS_PZ; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
u32 ClassifyFloat(float fvalue) |
||||
|
{ |
||||
|
// TODO: Optimize the below to be as fast as possible.
|
||||
|
IntFloat value; |
||||
|
value.f = fvalue; |
||||
|
u32 sign = value.i & FLOAT_SIGN; |
||||
|
u32 exp = value.i & FLOAT_EXP; |
||||
|
if (exp > FLOAT_ZERO && exp < FLOAT_EXP) |
||||
|
{ |
||||
|
// Nice normalized number.
|
||||
|
return sign ? PPC_FPCLASS_NN : PPC_FPCLASS_PN; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
u32 mantissa = value.i & FLOAT_FRAC; |
||||
|
if (mantissa) |
||||
|
{ |
||||
|
if (exp) |
||||
|
{ |
||||
|
return PPC_FPCLASS_QNAN; // Quiet NAN
|
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
// Denormalized number.
|
||||
|
return sign ? PPC_FPCLASS_ND : PPC_FPCLASS_PD; |
||||
|
} |
||||
|
} |
||||
|
else if (exp) |
||||
|
{ |
||||
|
// Infinite
|
||||
|
return sign ? PPC_FPCLASS_NINF : PPC_FPCLASS_PINF; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
//Zero
|
||||
|
return sign ? PPC_FPCLASS_NZ : PPC_FPCLASS_PZ; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
|
||||
|
} // namespace
|
||||
|
|
||||
|
inline void MatrixMul(int n, const float *a, const float *b, float *result) |
||||
|
{ |
||||
|
for (int i = 0; i < n; ++i) |
||||
|
{ |
||||
|
for (int j = 0; j < n; ++j) |
||||
|
{ |
||||
|
float temp = 0; |
||||
|
for (int k = 0; k < n; ++k) |
||||
|
{ |
||||
|
temp += a[i * n + k] * b[k * n + j]; |
||||
|
} |
||||
|
result[i * n + j] = temp; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// Calculate sum of a float list
|
||||
|
float MathFloatVectorSum(const std::vector<float>& Vec) |
||||
|
{ |
||||
|
return std::accumulate(Vec.begin(), Vec.end(), 0.0f); |
||||
|
} |
||||
|
|
||||
|
void Matrix33::LoadIdentity(Matrix33 &mtx) |
||||
|
{ |
||||
|
memset(mtx.data, 0, sizeof(mtx.data)); |
||||
|
mtx.data[0] = 1.0f; |
||||
|
mtx.data[4] = 1.0f; |
||||
|
mtx.data[8] = 1.0f; |
||||
|
} |
||||
|
|
||||
|
void Matrix33::RotateX(Matrix33 &mtx, float rad) |
||||
|
{ |
||||
|
float s = sin(rad); |
||||
|
float c = cos(rad); |
||||
|
memset(mtx.data, 0, sizeof(mtx.data)); |
||||
|
mtx.data[0] = 1; |
||||
|
mtx.data[4] = c; |
||||
|
mtx.data[5] = -s; |
||||
|
mtx.data[7] = s; |
||||
|
mtx.data[8] = c; |
||||
|
} |
||||
|
void Matrix33::RotateY(Matrix33 &mtx, float rad) |
||||
|
{ |
||||
|
float s = sin(rad); |
||||
|
float c = cos(rad); |
||||
|
memset(mtx.data, 0, sizeof(mtx.data)); |
||||
|
mtx.data[0] = c; |
||||
|
mtx.data[2] = s; |
||||
|
mtx.data[4] = 1; |
||||
|
mtx.data[6] = -s; |
||||
|
mtx.data[8] = c; |
||||
|
} |
||||
|
|
||||
|
void Matrix33::Multiply(const Matrix33 &a, const Matrix33 &b, Matrix33 &result) |
||||
|
{ |
||||
|
MatrixMul(3, a.data, b.data, result.data); |
||||
|
} |
||||
|
|
||||
|
void Matrix33::Multiply(const Matrix33 &a, const float vec[3], float result[3]) |
||||
|
{ |
||||
|
for (int i = 0; i < 3; ++i) { |
||||
|
result[i] = 0; |
||||
|
for (int k = 0; k < 3; ++k) { |
||||
|
result[i] += a.data[i * 3 + k] * vec[k]; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
void Matrix44::LoadIdentity(Matrix44 &mtx) |
||||
|
{ |
||||
|
memset(mtx.data, 0, sizeof(mtx.data)); |
||||
|
mtx.data[0] = 1.0f; |
||||
|
mtx.data[5] = 1.0f; |
||||
|
mtx.data[10] = 1.0f; |
||||
|
mtx.data[15] = 1.0f; |
||||
|
} |
||||
|
|
||||
|
void Matrix44::LoadMatrix33(Matrix44 &mtx, const Matrix33 &m33) |
||||
|
{ |
||||
|
for (int i = 0; i < 3; ++i) |
||||
|
{ |
||||
|
for (int j = 0; j < 3; ++j) |
||||
|
{ |
||||
|
mtx.data[i * 4 + j] = m33.data[i * 3 + j]; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
for (int i = 0; i < 3; ++i) |
||||
|
{ |
||||
|
mtx.data[i * 4 + 3] = 0; |
||||
|
mtx.data[i + 12] = 0; |
||||
|
} |
||||
|
mtx.data[15] = 1.0f; |
||||
|
} |
||||
|
|
||||
|
void Matrix44::Set(Matrix44 &mtx, const float mtxArray[16]) |
||||
|
{ |
||||
|
for(int i = 0; i < 16; ++i) { |
||||
|
mtx.data[i] = mtxArray[i]; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
void Matrix44::Translate(Matrix44 &mtx, const float vec[3]) |
||||
|
{ |
||||
|
LoadIdentity(mtx); |
||||
|
mtx.data[3] = vec[0]; |
||||
|
mtx.data[7] = vec[1]; |
||||
|
mtx.data[11] = vec[2]; |
||||
|
} |
||||
|
|
||||
|
void Matrix44::Multiply(const Matrix44 &a, const Matrix44 &b, Matrix44 &result) |
||||
|
{ |
||||
|
MatrixMul(4, a.data, b.data, result.data); |
||||
|
} |
||||
|
|
||||
@ -0,0 +1,200 @@ |
|||||
|
// Copyright 2013 Dolphin Emulator Project |
||||
|
// Licensed under GPLv2 |
||||
|
// Refer to the license.txt file included. |
||||
|
|
||||
|
|
||||
|
#ifndef _MATH_UTIL_H_ |
||||
|
#define _MATH_UTIL_H_ |
||||
|
|
||||
|
#include "common.h" |
||||
|
|
||||
|
#include <vector> |
||||
|
|
||||
|
namespace MathUtil |
||||
|
{ |
||||
|
|
||||
|
static const u64 DOUBLE_SIGN = 0x8000000000000000ULL, |
||||
|
DOUBLE_EXP = 0x7FF0000000000000ULL, |
||||
|
DOUBLE_FRAC = 0x000FFFFFFFFFFFFFULL, |
||||
|
DOUBLE_ZERO = 0x0000000000000000ULL; |
||||
|
|
||||
|
static const u32 FLOAT_SIGN = 0x80000000, |
||||
|
FLOAT_EXP = 0x7F800000, |
||||
|
FLOAT_FRAC = 0x007FFFFF, |
||||
|
FLOAT_ZERO = 0x00000000; |
||||
|
|
||||
|
union IntDouble { |
||||
|
double d; |
||||
|
u64 i; |
||||
|
}; |
||||
|
union IntFloat { |
||||
|
float f; |
||||
|
u32 i; |
||||
|
}; |
||||
|
|
||||
|
inline bool IsNAN(double d) |
||||
|
{ |
||||
|
IntDouble x; x.d = d; |
||||
|
return ( ((x.i & DOUBLE_EXP) == DOUBLE_EXP) && |
||||
|
((x.i & DOUBLE_FRAC) != DOUBLE_ZERO) ); |
||||
|
} |
||||
|
|
||||
|
inline bool IsQNAN(double d) |
||||
|
{ |
||||
|
IntDouble x; x.d = d; |
||||
|
return ( ((x.i & DOUBLE_EXP) == DOUBLE_EXP) && |
||||
|
((x.i & 0x0007fffffffffffULL) == 0x000000000000000ULL) && |
||||
|
((x.i & 0x000800000000000ULL) == 0x000800000000000ULL) ); |
||||
|
} |
||||
|
|
||||
|
inline bool IsSNAN(double d) |
||||
|
{ |
||||
|
IntDouble x; x.d = d; |
||||
|
return( ((x.i & DOUBLE_EXP) == DOUBLE_EXP) && |
||||
|
((x.i & DOUBLE_FRAC) != DOUBLE_ZERO) && |
||||
|
((x.i & 0x0008000000000000ULL) == DOUBLE_ZERO) ); |
||||
|
} |
||||
|
|
||||
|
inline float FlushToZero(float f) |
||||
|
{ |
||||
|
IntFloat x; x.f = f; |
||||
|
if ((x.i & FLOAT_EXP) == 0) |
||||
|
x.i &= FLOAT_SIGN; // turn into signed zero |
||||
|
return x.f; |
||||
|
} |
||||
|
|
||||
|
inline double FlushToZeroAsFloat(double d) |
||||
|
{ |
||||
|
IntDouble x; x.d = d; |
||||
|
if ((x.i & DOUBLE_EXP) < 0x3800000000000000ULL) |
||||
|
x.i &= DOUBLE_SIGN; // turn into signed zero |
||||
|
return x.d; |
||||
|
} |
||||
|
|
||||
|
enum PPCFpClass |
||||
|
{ |
||||
|
PPC_FPCLASS_QNAN = 0x11, |
||||
|
PPC_FPCLASS_NINF = 0x9, |
||||
|
PPC_FPCLASS_NN = 0x8, |
||||
|
PPC_FPCLASS_ND = 0x18, |
||||
|
PPC_FPCLASS_NZ = 0x12, |
||||
|
PPC_FPCLASS_PZ = 0x2, |
||||
|
PPC_FPCLASS_PD = 0x14, |
||||
|
PPC_FPCLASS_PN = 0x4, |
||||
|
PPC_FPCLASS_PINF = 0x5, |
||||
|
}; |
||||
|
|
||||
|
// Uses PowerPC conventions for the return value, so it can be easily |
||||
|
// used directly in CPU emulation. |
||||
|
u32 ClassifyDouble(double dvalue); |
||||
|
// More efficient float version. |
||||
|
u32 ClassifyFloat(float fvalue); |
||||
|
|
||||
|
template<class T> |
||||
|
struct Rectangle |
||||
|
{ |
||||
|
T left; |
||||
|
T top; |
||||
|
T right; |
||||
|
T bottom; |
||||
|
|
||||
|
Rectangle() |
||||
|
{ } |
||||
|
|
||||
|
Rectangle(T theLeft, T theTop, T theRight, T theBottom) |
||||
|
: left(theLeft), top(theTop), right(theRight), bottom(theBottom) |
||||
|
{ } |
||||
|
|
||||
|
bool operator==(const Rectangle& r) { return left==r.left && top==r.top && right==r.right && bottom==r.bottom; } |
||||
|
|
||||
|
T GetWidth() const { return abs(right - left); } |
||||
|
T GetHeight() const { return abs(bottom - top); } |
||||
|
|
||||
|
// If the rectangle is in a coordinate system with a lower-left origin, use |
||||
|
// this Clamp. |
||||
|
void ClampLL(T x1, T y1, T x2, T y2) |
||||
|
{ |
||||
|
if (left < x1) left = x1; |
||||
|
if (right > x2) right = x2; |
||||
|
if (top > y1) top = y1; |
||||
|
if (bottom < y2) bottom = y2; |
||||
|
} |
||||
|
|
||||
|
// If the rectangle is in a coordinate system with an upper-left origin, |
||||
|
// use this Clamp. |
||||
|
void ClampUL(T x1, T y1, T x2, T y2) |
||||
|
{ |
||||
|
if (left < x1) left = x1; |
||||
|
if (right > x2) right = x2; |
||||
|
if (top < y1) top = y1; |
||||
|
if (bottom > y2) bottom = y2; |
||||
|
} |
||||
|
}; |
||||
|
|
||||
|
} // namespace MathUtil |
||||
|
|
||||
|
inline float pow2f(float x) {return x * x;} |
||||
|
inline double pow2(double x) {return x * x;} |
||||
|
|
||||
|
float MathFloatVectorSum(const std::vector<float>&); |
||||
|
|
||||
|
#define ROUND_UP(x, a) (((x) + (a) - 1) & ~((a) - 1)) |
||||
|
#define ROUND_DOWN(x, a) ((x) & ~((a) - 1)) |
||||
|
|
||||
|
// Rounds down. 0 -> undefined |
||||
|
inline u64 Log2(u64 val) |
||||
|
{ |
||||
|
#if defined(__GNUC__) |
||||
|
return 63 - __builtin_clzll(val); |
||||
|
|
||||
|
#elif defined(_MSC_VER) && defined(_M_X64) |
||||
|
unsigned long result = -1; |
||||
|
_BitScanReverse64(&result, val); |
||||
|
return result; |
||||
|
|
||||
|
#else |
||||
|
u64 result = -1; |
||||
|
while (val != 0) |
||||
|
{ |
||||
|
val >>= 1; |
||||
|
++result; |
||||
|
} |
||||
|
return result; |
||||
|
#endif |
||||
|
} |
||||
|
|
||||
|
// Tiny matrix/vector library. |
||||
|
// Used for things like Free-Look in the gfx backend. |
||||
|
|
||||
|
class Matrix33 |
||||
|
{ |
||||
|
public: |
||||
|
static void LoadIdentity(Matrix33 &mtx); |
||||
|
|
||||
|
// set mtx to be a rotation matrix around the x axis |
||||
|
static void RotateX(Matrix33 &mtx, float rad); |
||||
|
// set mtx to be a rotation matrix around the y axis |
||||
|
static void RotateY(Matrix33 &mtx, float rad); |
||||
|
|
||||
|
// set result = a x b |
||||
|
static void Multiply(const Matrix33 &a, const Matrix33 &b, Matrix33 &result); |
||||
|
static void Multiply(const Matrix33 &a, const float vec[3], float result[3]); |
||||
|
|
||||
|
float data[9]; |
||||
|
}; |
||||
|
|
||||
|
class Matrix44 |
||||
|
{ |
||||
|
public: |
||||
|
static void LoadIdentity(Matrix44 &mtx); |
||||
|
static void LoadMatrix33(Matrix44 &mtx, const Matrix33 &m33); |
||||
|
static void Set(Matrix44 &mtx, const float mtxArray[16]); |
||||
|
|
||||
|
static void Translate(Matrix44 &mtx, const float vec[3]); |
||||
|
|
||||
|
static void Multiply(const Matrix44 &a, const Matrix44 &b, Matrix44 &result); |
||||
|
|
||||
|
float data[16]; |
||||
|
}; |
||||
|
|
||||
|
#endif // _MATH_UTIL_H_ |
||||
@ -0,0 +1,304 @@ |
|||||
|
// Copyright 2013 Dolphin Emulator Project
|
||||
|
// Licensed under GPLv2
|
||||
|
// Refer to the license.txt file included.
|
||||
|
|
||||
|
|
||||
|
#include "common.h"
|
||||
|
#include "memory_util.h"
|
||||
|
#include "mem_arena.h"
|
||||
|
|
||||
|
#ifdef _WIN32
|
||||
|
#include <windows.h>
|
||||
|
#else
|
||||
|
#include <sys/stat.h>
|
||||
|
#include <fcntl.h>
|
||||
|
#include <unistd.h>
|
||||
|
#include <cerrno>
|
||||
|
#include <cstring>
|
||||
|
#ifdef ANDROID
|
||||
|
#include <sys/ioctl.h>
|
||||
|
#include <linux/ashmem.h>
|
||||
|
#endif
|
||||
|
#endif
|
||||
|
#include <set>
|
||||
|
|
||||
|
#if defined(__APPLE__)
|
||||
|
static const char* ram_temp_file = "/tmp/gc_mem.tmp"; |
||||
|
#elif !defined(_WIN32) // non OSX unixes
|
||||
|
static const char* ram_temp_file = "/dev/shm/gc_mem.tmp"; |
||||
|
#endif
|
||||
|
#ifdef ANDROID
|
||||
|
#define ASHMEM_DEVICE "/dev/ashmem"
|
||||
|
|
||||
|
int AshmemCreateFileMapping(const char *name, size_t size) |
||||
|
{ |
||||
|
int fd, ret; |
||||
|
fd = open(ASHMEM_DEVICE, O_RDWR); |
||||
|
if (fd < 0) |
||||
|
return fd; |
||||
|
|
||||
|
// We don't really care if we can't set the name, it is optional
|
||||
|
ret = ioctl(fd, ASHMEM_SET_NAME, name); |
||||
|
|
||||
|
ret = ioctl(fd, ASHMEM_SET_SIZE, size); |
||||
|
if (ret < 0) |
||||
|
{ |
||||
|
close(fd); |
||||
|
NOTICE_LOG(MEMMAP, "Ashmem returned error: 0x%08x", ret); |
||||
|
return ret; |
||||
|
} |
||||
|
return fd; |
||||
|
} |
||||
|
#endif
|
||||
|
|
||||
|
void MemArena::GrabLowMemSpace(size_t size) |
||||
|
{ |
||||
|
#ifdef _WIN32
|
||||
|
hMemoryMapping = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, (DWORD)(size), NULL); |
||||
|
#elif defined(ANDROID)
|
||||
|
fd = AshmemCreateFileMapping("Dolphin-emu", size); |
||||
|
if (fd < 0) |
||||
|
{ |
||||
|
NOTICE_LOG(MEMMAP, "Ashmem allocation failed"); |
||||
|
return; |
||||
|
} |
||||
|
#else
|
||||
|
mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH; |
||||
|
fd = open(ram_temp_file, O_RDWR | O_CREAT, mode); |
||||
|
unlink(ram_temp_file); |
||||
|
if (ftruncate(fd, size) < 0) |
||||
|
ERROR_LOG(MEMMAP, "Failed to allocate low memory space"); |
||||
|
return; |
||||
|
#endif
|
||||
|
} |
||||
|
|
||||
|
|
||||
|
void MemArena::ReleaseSpace() |
||||
|
{ |
||||
|
#ifdef _WIN32
|
||||
|
CloseHandle(hMemoryMapping); |
||||
|
hMemoryMapping = 0; |
||||
|
#else
|
||||
|
close(fd); |
||||
|
#endif
|
||||
|
} |
||||
|
|
||||
|
|
||||
|
void *MemArena::CreateView(s64 offset, size_t size, void *base) |
||||
|
{ |
||||
|
#ifdef _WIN32
|
||||
|
return MapViewOfFileEx(hMemoryMapping, FILE_MAP_ALL_ACCESS, 0, (DWORD)((u64)offset), size, base); |
||||
|
#else
|
||||
|
void *retval = mmap( |
||||
|
base, size, |
||||
|
PROT_READ | PROT_WRITE, |
||||
|
MAP_SHARED | ((base == nullptr) ? 0 : MAP_FIXED), |
||||
|
fd, offset); |
||||
|
|
||||
|
if (retval == MAP_FAILED) |
||||
|
{ |
||||
|
NOTICE_LOG(MEMMAP, "mmap on %s failed", ram_temp_file); |
||||
|
return nullptr; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
return retval; |
||||
|
} |
||||
|
#endif
|
||||
|
} |
||||
|
|
||||
|
|
||||
|
void MemArena::ReleaseView(void* view, size_t size) |
||||
|
{ |
||||
|
#ifdef _WIN32
|
||||
|
UnmapViewOfFile(view); |
||||
|
#else
|
||||
|
munmap(view, size); |
||||
|
#endif
|
||||
|
} |
||||
|
|
||||
|
|
||||
|
u8* MemArena::Find4GBBase() |
||||
|
{ |
||||
|
#ifdef _M_X64
|
||||
|
#ifdef _WIN32
|
||||
|
// 64 bit
|
||||
|
u8* base = (u8*)VirtualAlloc(0, 0xE1000000, MEM_RESERVE, PAGE_READWRITE); |
||||
|
VirtualFree(base, 0, MEM_RELEASE); |
||||
|
return base; |
||||
|
#else
|
||||
|
// Very precarious - mmap cannot return an error when trying to map already used pages.
|
||||
|
// This makes the Windows approach above unusable on Linux, so we will simply pray...
|
||||
|
return reinterpret_cast<u8*>(0x2300000000ULL); |
||||
|
#endif
|
||||
|
|
||||
|
#else
|
||||
|
// 32 bit
|
||||
|
#ifdef _WIN32
|
||||
|
// The highest thing in any 1GB section of memory space is the locked cache. We only need to fit it.
|
||||
|
u8* base = (u8*)VirtualAlloc(0, 0x31000000, MEM_RESERVE, PAGE_READWRITE); |
||||
|
if (base) { |
||||
|
VirtualFree(base, 0, MEM_RELEASE); |
||||
|
} |
||||
|
return base; |
||||
|
#else
|
||||
|
#ifdef ANDROID
|
||||
|
// Android 4.3 changed how mmap works.
|
||||
|
// if we map it private and then munmap it, we can't use the base returned.
|
||||
|
// This may be due to changes in them support a full SELinux implementation.
|
||||
|
const int flags = MAP_ANON; |
||||
|
#else
|
||||
|
const int flags = MAP_ANON | MAP_PRIVATE; |
||||
|
#endif
|
||||
|
const u32 MemSize = 0x31000000; |
||||
|
void* base = mmap(0, MemSize, PROT_NONE, flags, -1, 0); |
||||
|
if (base == MAP_FAILED) { |
||||
|
PanicAlert("Failed to map 1 GB of memory space: %s", strerror(errno)); |
||||
|
return 0; |
||||
|
} |
||||
|
munmap(base, MemSize); |
||||
|
return static_cast<u8*>(base); |
||||
|
#endif
|
||||
|
#endif
|
||||
|
} |
||||
|
|
||||
|
|
||||
|
// yeah, this could also be done in like two bitwise ops...
|
||||
|
#define SKIP(a_flags, b_flags) \
|
||||
|
if (!(a_flags & MV_WII_ONLY) && (b_flags & MV_WII_ONLY)) \ |
||||
|
continue; \ |
||||
|
if (!(a_flags & MV_FAKE_VMEM) && (b_flags & MV_FAKE_VMEM)) \ |
||||
|
continue; \ |
||||
|
|
||||
|
|
||||
|
static bool Memory_TryBase(u8 *base, const MemoryView *views, int num_views, u32 flags, MemArena *arena) { |
||||
|
// OK, we know where to find free space. Now grab it!
|
||||
|
// We just mimic the popular BAT setup.
|
||||
|
u32 position = 0; |
||||
|
u32 last_position = 0; |
||||
|
|
||||
|
// Zero all the pointers to be sure.
|
||||
|
for (int i = 0; i < num_views; i++) |
||||
|
{ |
||||
|
if (views[i].out_ptr_low) |
||||
|
*views[i].out_ptr_low = 0; |
||||
|
if (views[i].out_ptr) |
||||
|
*views[i].out_ptr = 0; |
||||
|
} |
||||
|
|
||||
|
int i; |
||||
|
for (i = 0; i < num_views; i++) |
||||
|
{ |
||||
|
SKIP(flags, views[i].flags); |
||||
|
if (views[i].flags & MV_MIRROR_PREVIOUS) { |
||||
|
position = last_position; |
||||
|
} else { |
||||
|
*(views[i].out_ptr_low) = (u8*)arena->CreateView(position, views[i].size); |
||||
|
if (!*views[i].out_ptr_low) |
||||
|
goto bail; |
||||
|
} |
||||
|
#ifdef _M_X64
|
||||
|
*views[i].out_ptr = (u8*)arena->CreateView( |
||||
|
position, views[i].size, base + views[i].virtual_address); |
||||
|
#else
|
||||
|
if (views[i].flags & MV_MIRROR_PREVIOUS) { |
||||
|
// No need to create multiple identical views.
|
||||
|
*views[i].out_ptr = *views[i - 1].out_ptr; |
||||
|
} else { |
||||
|
*views[i].out_ptr = (u8*)arena->CreateView( |
||||
|
position, views[i].size, base + (views[i].virtual_address & 0x3FFFFFFF)); |
||||
|
if (!*views[i].out_ptr) |
||||
|
goto bail; |
||||
|
} |
||||
|
#endif
|
||||
|
last_position = position; |
||||
|
position += views[i].size; |
||||
|
} |
||||
|
|
||||
|
return true; |
||||
|
|
||||
|
bail: |
||||
|
// Argh! ERROR! Free what we grabbed so far so we can try again.
|
||||
|
MemoryMap_Shutdown(views, i+1, flags, arena); |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
u8 *MemoryMap_Setup(const MemoryView *views, int num_views, u32 flags, MemArena *arena) |
||||
|
{ |
||||
|
u32 total_mem = 0; |
||||
|
int base_attempts = 0; |
||||
|
|
||||
|
for (int i = 0; i < num_views; i++) |
||||
|
{ |
||||
|
SKIP(flags, views[i].flags); |
||||
|
if ((views[i].flags & MV_MIRROR_PREVIOUS) == 0) |
||||
|
total_mem += views[i].size; |
||||
|
} |
||||
|
// Grab some pagefile backed memory out of the void ...
|
||||
|
arena->GrabLowMemSpace(total_mem); |
||||
|
|
||||
|
// Now, create views in high memory where there's plenty of space.
|
||||
|
#ifdef _M_X64
|
||||
|
u8 *base = MemArena::Find4GBBase(); |
||||
|
// This really shouldn't fail - in 64-bit, there will always be enough
|
||||
|
// address space.
|
||||
|
if (!Memory_TryBase(base, views, num_views, flags, arena)) |
||||
|
{ |
||||
|
PanicAlert("MemoryMap_Setup: Failed finding a memory base."); |
||||
|
exit(0); |
||||
|
return 0; |
||||
|
} |
||||
|
#else
|
||||
|
#ifdef _WIN32
|
||||
|
// Try a whole range of possible bases. Return once we got a valid one.
|
||||
|
u32 max_base_addr = 0x7FFF0000 - 0x31000000; |
||||
|
u8 *base = NULL; |
||||
|
|
||||
|
for (u32 base_addr = 0x40000; base_addr < max_base_addr; base_addr += 0x40000) |
||||
|
{ |
||||
|
base_attempts++; |
||||
|
base = (u8 *)base_addr; |
||||
|
if (Memory_TryBase(base, views, num_views, flags, arena)) |
||||
|
{ |
||||
|
INFO_LOG(MEMMAP, "Found valid memory base at %p after %i tries.", base, base_attempts); |
||||
|
base_attempts = 0; |
||||
|
break; |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
#else
|
||||
|
// Linux32 is fine with the x64 method, although limited to 32-bit with no automirrors.
|
||||
|
u8 *base = MemArena::Find4GBBase(); |
||||
|
if (!Memory_TryBase(base, views, num_views, flags, arena)) |
||||
|
{ |
||||
|
PanicAlert("MemoryMap_Setup: Failed finding a memory base."); |
||||
|
exit(0); |
||||
|
return 0; |
||||
|
} |
||||
|
#endif
|
||||
|
|
||||
|
#endif
|
||||
|
if (base_attempts) |
||||
|
PanicAlert("No possible memory base pointer found!"); |
||||
|
return base; |
||||
|
} |
||||
|
|
||||
|
void MemoryMap_Shutdown(const MemoryView *views, int num_views, u32 flags, MemArena *arena) |
||||
|
{ |
||||
|
std::set<void*> freeset; |
||||
|
for (int i = 0; i < num_views; i++) |
||||
|
{ |
||||
|
const MemoryView* view = &views[i]; |
||||
|
u8** outptrs[2] = {view->out_ptr_low, view->out_ptr}; |
||||
|
for (int j = 0; j < 2; j++) |
||||
|
{ |
||||
|
u8** outptr = outptrs[j]; |
||||
|
if (outptr && *outptr && !freeset.count(*outptr)) |
||||
|
{ |
||||
|
arena->ReleaseView(*outptr, view->size); |
||||
|
freeset.insert(*outptr); |
||||
|
*outptr = NULL; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,58 @@ |
|||||
|
// Copyright 2013 Dolphin Emulator Project |
||||
|
// Licensed under GPLv2 |
||||
|
// Refer to the license.txt file included. |
||||
|
|
||||
|
|
||||
|
#ifndef _MEMARENA_H_ |
||||
|
#define _MEMARENA_H_ |
||||
|
|
||||
|
#ifdef _WIN32 |
||||
|
#include <windows.h> |
||||
|
#endif |
||||
|
|
||||
|
#include "common.h" |
||||
|
|
||||
|
// This class lets you create a block of anonymous RAM, and then arbitrarily map views into it. |
||||
|
// Multiple views can mirror the same section of the block, which makes it very convenient for emulating |
||||
|
// memory mirrors. |
||||
|
|
||||
|
class MemArena |
||||
|
{ |
||||
|
public: |
||||
|
void GrabLowMemSpace(size_t size); |
||||
|
void ReleaseSpace(); |
||||
|
void *CreateView(s64 offset, size_t size, void *base = nullptr); |
||||
|
void ReleaseView(void *view, size_t size); |
||||
|
|
||||
|
// This only finds 1 GB in 32-bit |
||||
|
static u8 *Find4GBBase(); |
||||
|
private: |
||||
|
|
||||
|
#ifdef _WIN32 |
||||
|
HANDLE hMemoryMapping; |
||||
|
#else |
||||
|
int fd; |
||||
|
#endif |
||||
|
}; |
||||
|
|
||||
|
enum { |
||||
|
MV_MIRROR_PREVIOUS = 1, |
||||
|
MV_FAKE_VMEM = 2, |
||||
|
MV_WII_ONLY = 4, |
||||
|
}; |
||||
|
|
||||
|
struct MemoryView |
||||
|
{ |
||||
|
u8 **out_ptr_low; |
||||
|
u8 **out_ptr; |
||||
|
u32 virtual_address; |
||||
|
u32 size; |
||||
|
u32 flags; |
||||
|
}; |
||||
|
|
||||
|
// Uses a memory arena to set up an emulator-friendly memory map according to |
||||
|
// a passed-in list of MemoryView structures. |
||||
|
u8 *MemoryMap_Setup(const MemoryView *views, int num_views, u32 flags, MemArena *arena); |
||||
|
void MemoryMap_Shutdown(const MemoryView *views, int num_views, u32 flags, MemArena *arena); |
||||
|
|
||||
|
#endif // _MEMARENA_H_ |
||||
@ -0,0 +1,197 @@ |
|||||
|
// Copyright 2013 Dolphin Emulator Project
|
||||
|
// Licensed under GPLv2
|
||||
|
// Refer to the license.txt file included.
|
||||
|
|
||||
|
|
||||
|
#include "common.h"
|
||||
|
#include "memory_util.h"
|
||||
|
#include "string_util.h"
|
||||
|
|
||||
|
#ifdef _WIN32
|
||||
|
#include <windows.h>
|
||||
|
#include <psapi.h>
|
||||
|
#else
|
||||
|
#include <errno.h>
|
||||
|
#include <stdio.h>
|
||||
|
#endif
|
||||
|
|
||||
|
#if !defined(_WIN32) && defined(__x86_64__) && !defined(MAP_32BIT)
|
||||
|
#include <unistd.h>
|
||||
|
#define PAGE_MASK (getpagesize() - 1)
|
||||
|
#define round_page(x) ((((unsigned long)(x)) + PAGE_MASK) & ~(PAGE_MASK))
|
||||
|
#endif
|
||||
|
|
||||
|
// This is purposely not a full wrapper for virtualalloc/mmap, but it
|
||||
|
// provides exactly the primitive operations that Dolphin needs.
|
||||
|
|
||||
|
void* AllocateExecutableMemory(size_t size, bool low) |
||||
|
{ |
||||
|
#if defined(_WIN32)
|
||||
|
void* ptr = VirtualAlloc(0, size, MEM_COMMIT, PAGE_EXECUTE_READWRITE); |
||||
|
#else
|
||||
|
static char *map_hint = 0; |
||||
|
#if defined(__x86_64__) && !defined(MAP_32BIT)
|
||||
|
// This OS has no flag to enforce allocation below the 4 GB boundary,
|
||||
|
// but if we hint that we want a low address it is very likely we will
|
||||
|
// get one.
|
||||
|
// An older version of this code used MAP_FIXED, but that has the side
|
||||
|
// effect of discarding already mapped pages that happen to be in the
|
||||
|
// requested virtual memory range (such as the emulated RAM, sometimes).
|
||||
|
if (low && (!map_hint)) |
||||
|
map_hint = (char*)round_page(512*1024*1024); /* 0.5 GB rounded up to the next page */ |
||||
|
#endif
|
||||
|
void* ptr = mmap(map_hint, size, PROT_READ | PROT_WRITE | PROT_EXEC, |
||||
|
MAP_ANON | MAP_PRIVATE |
||||
|
#if defined(__x86_64__) && defined(MAP_32BIT)
|
||||
|
| (low ? MAP_32BIT : 0) |
||||
|
#endif
|
||||
|
, -1, 0); |
||||
|
#endif /* defined(_WIN32) */
|
||||
|
|
||||
|
// printf("Mapped executable memory at %p (size %ld)\n", ptr,
|
||||
|
// (unsigned long)size);
|
||||
|
|
||||
|
#if defined(__FreeBSD__)
|
||||
|
if (ptr == MAP_FAILED) |
||||
|
{ |
||||
|
ptr = NULL; |
||||
|
#else
|
||||
|
if (ptr == NULL) |
||||
|
{ |
||||
|
#endif
|
||||
|
PanicAlert("Failed to allocate executable memory"); |
||||
|
} |
||||
|
#if !defined(_WIN32) && defined(__x86_64__) && !defined(MAP_32BIT)
|
||||
|
else |
||||
|
{ |
||||
|
if (low) |
||||
|
{ |
||||
|
map_hint += size; |
||||
|
map_hint = (char*)round_page(map_hint); /* round up to the next page */ |
||||
|
// printf("Next map will (hopefully) be at %p\n", map_hint);
|
||||
|
} |
||||
|
} |
||||
|
#endif
|
||||
|
|
||||
|
#if defined(_M_X64)
|
||||
|
if ((u64)ptr >= 0x80000000 && low == true) |
||||
|
PanicAlert("Executable memory ended up above 2GB!"); |
||||
|
#endif
|
||||
|
|
||||
|
return ptr; |
||||
|
} |
||||
|
|
||||
|
void* AllocateMemoryPages(size_t size) |
||||
|
{ |
||||
|
#ifdef _WIN32
|
||||
|
void* ptr = VirtualAlloc(0, size, MEM_COMMIT, PAGE_READWRITE); |
||||
|
#else
|
||||
|
void* ptr = mmap(0, size, PROT_READ | PROT_WRITE, |
||||
|
MAP_ANON | MAP_PRIVATE, -1, 0); |
||||
|
#endif
|
||||
|
|
||||
|
// printf("Mapped memory at %p (size %ld)\n", ptr,
|
||||
|
// (unsigned long)size);
|
||||
|
|
||||
|
if (ptr == NULL) |
||||
|
PanicAlert("Failed to allocate raw memory"); |
||||
|
|
||||
|
return ptr; |
||||
|
} |
||||
|
|
||||
|
void* AllocateAlignedMemory(size_t size,size_t alignment) |
||||
|
{ |
||||
|
#ifdef _WIN32
|
||||
|
void* ptr = _aligned_malloc(size,alignment); |
||||
|
#else
|
||||
|
void* ptr = NULL; |
||||
|
#ifdef ANDROID
|
||||
|
ptr = memalign(alignment, size); |
||||
|
#else
|
||||
|
if (posix_memalign(&ptr, alignment, size) != 0) |
||||
|
ERROR_LOG(MEMMAP, "Failed to allocate aligned memory"); |
||||
|
#endif
|
||||
|
#endif
|
||||
|
|
||||
|
// printf("Mapped memory at %p (size %ld)\n", ptr,
|
||||
|
// (unsigned long)size);
|
||||
|
|
||||
|
if (ptr == NULL) |
||||
|
PanicAlert("Failed to allocate aligned memory"); |
||||
|
|
||||
|
return ptr; |
||||
|
} |
||||
|
|
||||
|
void FreeMemoryPages(void* ptr, size_t size) |
||||
|
{ |
||||
|
if (ptr) |
||||
|
{ |
||||
|
#ifdef _WIN32
|
||||
|
|
||||
|
if (!VirtualFree(ptr, 0, MEM_RELEASE)) |
||||
|
PanicAlert("FreeMemoryPages failed!\n%s", GetLastErrorMsg()); |
||||
|
ptr = NULL; // Is this our responsibility?
|
||||
|
|
||||
|
#else
|
||||
|
munmap(ptr, size); |
||||
|
#endif
|
||||
|
} |
||||
|
} |
||||
|
|
||||
|
void FreeAlignedMemory(void* ptr) |
||||
|
{ |
||||
|
if (ptr) |
||||
|
{ |
||||
|
#ifdef _WIN32
|
||||
|
_aligned_free(ptr); |
||||
|
#else
|
||||
|
free(ptr); |
||||
|
#endif
|
||||
|
} |
||||
|
} |
||||
|
|
||||
|
void WriteProtectMemory(void* ptr, size_t size, bool allowExecute) |
||||
|
{ |
||||
|
#ifdef _WIN32
|
||||
|
DWORD oldValue; |
||||
|
if (!VirtualProtect(ptr, size, allowExecute ? PAGE_EXECUTE_READ : PAGE_READONLY, &oldValue)) |
||||
|
PanicAlert("WriteProtectMemory failed!\n%s", GetLastErrorMsg()); |
||||
|
#else
|
||||
|
mprotect(ptr, size, allowExecute ? (PROT_READ | PROT_EXEC) : PROT_READ); |
||||
|
#endif
|
||||
|
} |
||||
|
|
||||
|
void UnWriteProtectMemory(void* ptr, size_t size, bool allowExecute) |
||||
|
{ |
||||
|
#ifdef _WIN32
|
||||
|
DWORD oldValue; |
||||
|
if (!VirtualProtect(ptr, size, allowExecute ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE, &oldValue)) |
||||
|
PanicAlert("UnWriteProtectMemory failed!\n%s", GetLastErrorMsg()); |
||||
|
#else
|
||||
|
mprotect(ptr, size, allowExecute ? (PROT_READ | PROT_WRITE | PROT_EXEC) : PROT_WRITE | PROT_READ); |
||||
|
#endif
|
||||
|
} |
||||
|
|
||||
|
std::string MemUsage() |
||||
|
{ |
||||
|
#ifdef _WIN32
|
||||
|
#pragma comment(lib, "psapi")
|
||||
|
DWORD processID = GetCurrentProcessId(); |
||||
|
HANDLE hProcess; |
||||
|
PROCESS_MEMORY_COUNTERS pmc; |
||||
|
std::string Ret; |
||||
|
|
||||
|
// Print information about the memory usage of the process.
|
||||
|
|
||||
|
hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, processID); |
||||
|
if (NULL == hProcess) return "MemUsage Error"; |
||||
|
|
||||
|
if (GetProcessMemoryInfo(hProcess, &pmc, sizeof(pmc))) |
||||
|
Ret = StringFromFormat("%s K", ThousandSeparate(pmc.WorkingSetSize / 1024, 7).c_str()); |
||||
|
|
||||
|
CloseHandle(hProcess); |
||||
|
return Ret; |
||||
|
#else
|
||||
|
return ""; |
||||
|
#endif
|
||||
|
} |
||||
@ -0,0 +1,25 @@ |
|||||
|
// Copyright 2013 Dolphin Emulator Project |
||||
|
// Licensed under GPLv2 |
||||
|
// Refer to the license.txt file included. |
||||
|
|
||||
|
|
||||
|
#ifndef _MEMORYUTIL_H |
||||
|
#define _MEMORYUTIL_H |
||||
|
|
||||
|
#ifndef _WIN32 |
||||
|
#include <sys/mman.h> |
||||
|
#endif |
||||
|
#include <string> |
||||
|
|
||||
|
void* AllocateExecutableMemory(size_t size, bool low = true); |
||||
|
void* AllocateMemoryPages(size_t size); |
||||
|
void FreeMemoryPages(void* ptr, size_t size); |
||||
|
void* AllocateAlignedMemory(size_t size,size_t alignment); |
||||
|
void FreeAlignedMemory(void* ptr); |
||||
|
void WriteProtectMemory(void* ptr, size_t size, bool executable = false); |
||||
|
void UnWriteProtectMemory(void* ptr, size_t size, bool allowExecute = false); |
||||
|
std::string MemUsage(); |
||||
|
|
||||
|
inline int GetPageSize() { return 4096; } |
||||
|
|
||||
|
#endif |
||||
@ -0,0 +1,33 @@ |
|||||
|
// Copyright 2013 Dolphin Emulator Project
|
||||
|
// Licensed under GPLv2
|
||||
|
// Refer to the license.txt file included.
|
||||
|
|
||||
|
#include "common.h"
|
||||
|
|
||||
|
// Neither Android nor OS X support TLS
|
||||
|
#if defined(__APPLE__) || (ANDROID && __clang__)
|
||||
|
#define __thread
|
||||
|
#endif
|
||||
|
|
||||
|
// Generic function to get last error message.
|
||||
|
// Call directly after the command or use the error num.
|
||||
|
// This function might change the error code.
|
||||
|
//const char* GetLastErrorMsg()
|
||||
|
//{
|
||||
|
// static const size_t buff_size = 255;
|
||||
|
//
|
||||
|
//#ifdef _WIN32
|
||||
|
// static __declspec(thread) char err_str[buff_size] = {};
|
||||
|
//
|
||||
|
// FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(),
|
||||
|
// MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
|
||||
|
// err_str, buff_size, NULL);
|
||||
|
//#else
|
||||
|
// static __thread char err_str[buff_size] = {};
|
||||
|
//
|
||||
|
// // Thread safe (XSI-compliant)
|
||||
|
// strerror_r(errno, err_str, buff_size);
|
||||
|
//#endif
|
||||
|
//
|
||||
|
// return err_str;
|
||||
|
//}
|
||||
@ -0,0 +1,107 @@ |
|||||
|
// Copyright 2013 Dolphin Emulator Project
|
||||
|
// Licensed under GPLv2
|
||||
|
// Refer to the license.txt file included.
|
||||
|
|
||||
|
#include <stdio.h> // System
|
||||
|
|
||||
|
#include "common.h" // Local
|
||||
|
#include "string_util.h"
|
||||
|
|
||||
|
bool DefaultMsgHandler(const char* caption, const char* text, bool yes_no, int Style); |
||||
|
static MsgAlertHandler msg_handler = DefaultMsgHandler; |
||||
|
static bool AlertEnabled = true; |
||||
|
|
||||
|
std::string DefaultStringTranslator(const char* text); |
||||
|
static StringTranslator str_translator = DefaultStringTranslator; |
||||
|
|
||||
|
// Select which of these functions that are used for message boxes. If
|
||||
|
// wxWidgets is enabled we will use wxMsgAlert() that is defined in Main.cpp
|
||||
|
void RegisterMsgAlertHandler(MsgAlertHandler handler) |
||||
|
{ |
||||
|
msg_handler = handler; |
||||
|
} |
||||
|
|
||||
|
// Select translation function. For wxWidgets use wxStringTranslator in Main.cpp
|
||||
|
void RegisterStringTranslator(StringTranslator translator) |
||||
|
{ |
||||
|
str_translator = translator; |
||||
|
} |
||||
|
|
||||
|
// enable/disable the alert handler
|
||||
|
void SetEnableAlert(bool enable) |
||||
|
{ |
||||
|
AlertEnabled = enable; |
||||
|
} |
||||
|
|
||||
|
// This is the first stop for gui alerts where the log is updated and the
|
||||
|
// correct window is shown
|
||||
|
bool MsgAlert(bool yes_no, int Style, const char* format, ...) |
||||
|
{ |
||||
|
// Read message and write it to the log
|
||||
|
std::string caption; |
||||
|
char buffer[2048]; |
||||
|
|
||||
|
static std::string info_caption; |
||||
|
static std::string warn_caption; |
||||
|
static std::string ques_caption; |
||||
|
static std::string crit_caption; |
||||
|
|
||||
|
if (!info_caption.length()) |
||||
|
{ |
||||
|
info_caption = str_translator(_trans("Information")); |
||||
|
ques_caption = str_translator(_trans("Question")); |
||||
|
warn_caption = str_translator(_trans("Warning")); |
||||
|
crit_caption = str_translator(_trans("Critical")); |
||||
|
} |
||||
|
|
||||
|
switch(Style) |
||||
|
{ |
||||
|
case INFORMATION: |
||||
|
caption = info_caption; |
||||
|
break; |
||||
|
case QUESTION: |
||||
|
caption = ques_caption; |
||||
|
break; |
||||
|
case WARNING: |
||||
|
caption = warn_caption; |
||||
|
break; |
||||
|
case CRITICAL: |
||||
|
caption = crit_caption; |
||||
|
break; |
||||
|
} |
||||
|
|
||||
|
va_list args; |
||||
|
va_start(args, format); |
||||
|
CharArrayFromFormatV(buffer, sizeof(buffer)-1, str_translator(format).c_str(), args); |
||||
|
va_end(args); |
||||
|
|
||||
|
ERROR_LOG(MASTER_LOG, "%s: %s", caption.c_str(), buffer); |
||||
|
|
||||
|
// Don't ignore questions, especially AskYesNo, PanicYesNo could be ignored
|
||||
|
if (msg_handler && (AlertEnabled || Style == QUESTION || Style == CRITICAL)) |
||||
|
return msg_handler(caption.c_str(), buffer, yes_no, Style); |
||||
|
|
||||
|
return true; |
||||
|
} |
||||
|
|
||||
|
// Default non library dependent panic alert
|
||||
|
bool DefaultMsgHandler(const char* caption, const char* text, bool yes_no, int Style) |
||||
|
{ |
||||
|
//#ifdef _WIN32
|
||||
|
// int STYLE = MB_ICONINFORMATION;
|
||||
|
// if (Style == QUESTION) STYLE = MB_ICONQUESTION;
|
||||
|
// if (Style == WARNING) STYLE = MB_ICONWARNING;
|
||||
|
//
|
||||
|
// return IDYES == MessageBox(0, UTF8ToTStr(text).c_str(), UTF8ToTStr(caption).c_str(), STYLE | (yes_no ? MB_YESNO : MB_OK));
|
||||
|
//#else
|
||||
|
printf("%s\n", text); |
||||
|
return true; |
||||
|
//#endif
|
||||
|
} |
||||
|
|
||||
|
// Default (non) translator
|
||||
|
std::string DefaultStringTranslator(const char* text) |
||||
|
{ |
||||
|
return text; |
||||
|
} |
||||
|
|
||||
@ -0,0 +1,73 @@ |
|||||
|
// Copyright 2013 Dolphin Emulator Project |
||||
|
// Licensed under GPLv2 |
||||
|
// Refer to the license.txt file included. |
||||
|
|
||||
|
#ifndef _MSGHANDLER_H_ |
||||
|
#define _MSGHANDLER_H_ |
||||
|
|
||||
|
#include <string> |
||||
|
|
||||
|
// Message alerts |
||||
|
enum MSG_TYPE |
||||
|
{ |
||||
|
INFORMATION, |
||||
|
QUESTION, |
||||
|
WARNING, |
||||
|
CRITICAL |
||||
|
}; |
||||
|
|
||||
|
typedef bool (*MsgAlertHandler)(const char* caption, const char* text, |
||||
|
bool yes_no, int Style); |
||||
|
typedef std::string (*StringTranslator)(const char* text); |
||||
|
|
||||
|
void RegisterMsgAlertHandler(MsgAlertHandler handler); |
||||
|
void RegisterStringTranslator(StringTranslator translator); |
||||
|
|
||||
|
extern bool MsgAlert(bool yes_no, int Style, const char* format, ...) |
||||
|
#ifdef __GNUC__ |
||||
|
__attribute__((format(printf, 3, 4))) |
||||
|
#endif |
||||
|
; |
||||
|
void SetEnableAlert(bool enable); |
||||
|
|
||||
|
#ifndef GEKKO |
||||
|
#ifdef _WIN32 |
||||
|
#define SuccessAlert(format, ...) MsgAlert(false, INFORMATION, format, __VA_ARGS__) |
||||
|
#define PanicAlert(format, ...) MsgAlert(false, WARNING, format, __VA_ARGS__) |
||||
|
#define PanicYesNo(format, ...) MsgAlert(true, WARNING, format, __VA_ARGS__) |
||||
|
#define AskYesNo(format, ...) MsgAlert(true, QUESTION, format, __VA_ARGS__) |
||||
|
#define CriticalAlert(format, ...) MsgAlert(false, CRITICAL, format, __VA_ARGS__) |
||||
|
// Use these macros (that do the same thing) if the message should be translated. |
||||
|
#define SuccessAlertT(format, ...) MsgAlert(false, INFORMATION, format, __VA_ARGS__) |
||||
|
#define PanicAlertT(format, ...) MsgAlert(false, WARNING, format, __VA_ARGS__) |
||||
|
#define PanicYesNoT(format, ...) MsgAlert(true, WARNING, format, __VA_ARGS__) |
||||
|
#define AskYesNoT(format, ...) MsgAlert(true, QUESTION, format, __VA_ARGS__) |
||||
|
#define CriticalAlertT(format, ...) MsgAlert(false, CRITICAL, format, __VA_ARGS__) |
||||
|
#else |
||||
|
#define SuccessAlert(format, ...) MsgAlert(false, INFORMATION, format, ##__VA_ARGS__) |
||||
|
#define PanicAlert(format, ...) MsgAlert(false, WARNING, format, ##__VA_ARGS__) |
||||
|
#define PanicYesNo(format, ...) MsgAlert(true, WARNING, format, ##__VA_ARGS__) |
||||
|
#define AskYesNo(format, ...) MsgAlert(true, QUESTION, format, ##__VA_ARGS__) |
||||
|
#define CriticalAlert(format, ...) MsgAlert(false, CRITICAL, format, ##__VA_ARGS__) |
||||
|
// Use these macros (that do the same thing) if the message should be translated. |
||||
|
#define SuccessAlertT(format, ...) MsgAlert(false, INFORMATION, format, ##__VA_ARGS__) |
||||
|
#define PanicAlertT(format, ...) MsgAlert(false, WARNING, format, ##__VA_ARGS__) |
||||
|
#define PanicYesNoT(format, ...) MsgAlert(true, WARNING, format, ##__VA_ARGS__) |
||||
|
#define AskYesNoT(format, ...) MsgAlert(true, QUESTION, format, ##__VA_ARGS__) |
||||
|
#define CriticalAlertT(format, ...) MsgAlert(false, CRITICAL, format, ##__VA_ARGS__) |
||||
|
#endif |
||||
|
#else |
||||
|
// GEKKO |
||||
|
#define SuccessAlert(format, ...) ; |
||||
|
#define PanicAlert(format, ...) ; |
||||
|
#define PanicYesNo(format, ...) ; |
||||
|
#define AskYesNo(format, ...) ; |
||||
|
#define CriticalAlert(format, ...) ; |
||||
|
#define SuccessAlertT(format, ...) ; |
||||
|
#define PanicAlertT(format, ...) ; |
||||
|
#define PanicYesNoT(format, ...) ; |
||||
|
#define AskYesNoT(format, ...) ; |
||||
|
#define CriticalAlertT(format, ...) ; |
||||
|
#endif |
||||
|
|
||||
|
#endif // _MSGHANDLER_H_ |
||||
@ -0,0 +1,4 @@ |
|||||
|
#define SCM_REV_STR "7d11f8cedd7c135d96880f19ecbd3ff87a60a11f" |
||||
|
#define SCM_DESC_STR "3.5-254-dirty" |
||||
|
#define SCM_BRANCH_STR "master" |
||||
|
#define SCM_IS_MASTER 1 |
||||
@ -0,0 +1,170 @@ |
|||||
|
|
||||
|
#ifndef CONDITION_VARIABLE_H_ |
||||
|
#define CONDITION_VARIABLE_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__ |
||||
|
|
||||
|
// GCC 4.4 provides <condition_variable> |
||||
|
#include <condition_variable> |
||||
|
|
||||
|
#elif __has_include(<condition_variable>) && !ANDROID |
||||
|
|
||||
|
// 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. |
||||
|
// |
||||
|
// We work around this issue by undefining and redefining _. |
||||
|
|
||||
|
#undef _ |
||||
|
#include <condition_variable> |
||||
|
#define _(s) wxGetTranslation((s)) |
||||
|
|
||||
|
#else |
||||
|
|
||||
|
// partial std::condition_variable implementation for win32/pthread |
||||
|
|
||||
|
#include "std_mutex.h" |
||||
|
|
||||
|
#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_CONDITION_VARIABLES |
||||
|
#elif defined(_WIN32) |
||||
|
#define USE_EVENTS |
||||
|
#endif |
||||
|
|
||||
|
namespace std |
||||
|
{ |
||||
|
|
||||
|
class condition_variable |
||||
|
{ |
||||
|
#if defined(_WIN32) && defined(USE_CONDITION_VARIABLES) |
||||
|
typedef CONDITION_VARIABLE native_type; |
||||
|
#elif defined(_WIN32) |
||||
|
typedef HANDLE native_type; |
||||
|
#else |
||||
|
typedef pthread_cond_t native_type; |
||||
|
#endif |
||||
|
|
||||
|
public: |
||||
|
|
||||
|
#ifdef USE_EVENTS |
||||
|
typedef native_type native_handle_type; |
||||
|
#else |
||||
|
typedef native_type* native_handle_type; |
||||
|
#endif |
||||
|
|
||||
|
condition_variable() |
||||
|
{ |
||||
|
#if defined(_WIN32) && defined(USE_CONDITION_VARIABLES) |
||||
|
InitializeConditionVariable(&m_handle); |
||||
|
#elif defined(_WIN32) |
||||
|
m_handle = CreateEvent(NULL, false, false, NULL); |
||||
|
#else |
||||
|
pthread_cond_init(&m_handle, NULL); |
||||
|
#endif |
||||
|
} |
||||
|
|
||||
|
~condition_variable() |
||||
|
{ |
||||
|
#if defined(_WIN32) && !defined(USE_CONDITION_VARIABLES) |
||||
|
CloseHandle(m_handle); |
||||
|
#elif !defined(_WIN32) |
||||
|
pthread_cond_destroy(&m_handle); |
||||
|
#endif |
||||
|
} |
||||
|
|
||||
|
condition_variable(const condition_variable&) /*= delete*/; |
||||
|
condition_variable& operator=(const condition_variable&) /*= delete*/; |
||||
|
|
||||
|
void notify_one() |
||||
|
{ |
||||
|
#if defined(_WIN32) && defined(USE_CONDITION_VARIABLES) |
||||
|
WakeConditionVariable(&m_handle); |
||||
|
#elif defined(_WIN32) |
||||
|
SetEvent(m_handle); |
||||
|
#else |
||||
|
pthread_cond_signal(&m_handle); |
||||
|
#endif |
||||
|
} |
||||
|
|
||||
|
void notify_all() |
||||
|
{ |
||||
|
#if defined(_WIN32) && defined(USE_CONDITION_VARIABLES) |
||||
|
WakeAllConditionVariable(&m_handle); |
||||
|
#elif defined(_WIN32) |
||||
|
// TODO: broken |
||||
|
SetEvent(m_handle); |
||||
|
#else |
||||
|
pthread_cond_broadcast(&m_handle); |
||||
|
#endif |
||||
|
} |
||||
|
|
||||
|
void wait(unique_lock<mutex>& lock) |
||||
|
{ |
||||
|
#ifdef _WIN32 |
||||
|
#ifdef USE_SRWLOCKS |
||||
|
SleepConditionVariableSRW(&m_handle, lock.mutex()->native_handle(), INFINITE, 0); |
||||
|
#elif defined(USE_CONDITION_VARIABLES) |
||||
|
SleepConditionVariableCS(&m_handle, lock.mutex()->native_handle(), INFINITE); |
||||
|
#else |
||||
|
// TODO: broken, the unlock and wait need to be atomic |
||||
|
lock.unlock(); |
||||
|
WaitForSingleObject(m_handle, INFINITE); |
||||
|
lock.lock(); |
||||
|
#endif |
||||
|
#else |
||||
|
pthread_cond_wait(&m_handle, lock.mutex()->native_handle()); |
||||
|
#endif |
||||
|
} |
||||
|
|
||||
|
template <class Predicate> |
||||
|
void wait(unique_lock<mutex>& lock, Predicate pred) |
||||
|
{ |
||||
|
while (!pred()) |
||||
|
wait(lock); |
||||
|
} |
||||
|
|
||||
|
//template <class Clock, class Duration> |
||||
|
//cv_status wait_until(unique_lock<mutex>& lock, |
||||
|
// const chrono::time_point<Clock, Duration>& abs_time); |
||||
|
|
||||
|
//template <class Clock, class Duration, class Predicate> |
||||
|
// bool wait_until(unique_lock<mutex>& lock, |
||||
|
// const chrono::time_point<Clock, Duration>& abs_time, |
||||
|
// Predicate pred); |
||||
|
|
||||
|
//template <class Rep, class Period> |
||||
|
//cv_status wait_for(unique_lock<mutex>& lock, |
||||
|
// const chrono::duration<Rep, Period>& rel_time); |
||||
|
|
||||
|
//template <class Rep, class Period, class Predicate> |
||||
|
// bool wait_for(unique_lock<mutex>& lock, |
||||
|
// const chrono::duration<Rep, Period>& rel_time, |
||||
|
// Predicate pred); |
||||
|
|
||||
|
native_handle_type native_handle() |
||||
|
{ |
||||
|
#ifdef USE_EVENTS |
||||
|
return m_handle; |
||||
|
#else |
||||
|
return &m_handle; |
||||
|
#endif |
||||
|
} |
||||
|
|
||||
|
private: |
||||
|
native_type m_handle; |
||||
|
}; |
||||
|
|
||||
|
} |
||||
|
|
||||
|
#endif |
||||
|
#endif |
||||
@ -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__ |
||||
|
// GCC 4.4 provides <mutex> |
||||
|
#include <mutex> |
||||
|
#elif __has_include(<mutex>) && !ANDROID |
||||
|
// 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 |
||||
@ -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__ |
||||
|
// GCC 4.4 provides <thread> |
||||
|
#ifndef _GLIBCXX_USE_SCHED_YIELD |
||||
|
#define _GLIBCXX_USE_SCHED_YIELD |
||||
|
#endif |
||||
|
#include <thread> |
||||
|
#elif __has_include(<thread>) && !ANDROID |
||||
|
// 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 |
||||
@ -0,0 +1,531 @@ |
|||||
|
// Copyright 2013 Dolphin Emulator Project
|
||||
|
// Licensed under GPLv2
|
||||
|
// Refer to the license.txt file included.
|
||||
|
|
||||
|
#include <stdlib.h>
|
||||
|
#include <stdio.h>
|
||||
|
#include <algorithm>
|
||||
|
|
||||
|
#include "common.h"
|
||||
|
#include "common_paths.h"
|
||||
|
#include "string_util.h"
|
||||
|
|
||||
|
#ifdef _WIN32
|
||||
|
#include <Windows.h>
|
||||
|
#else
|
||||
|
#include <iconv.h>
|
||||
|
#include <errno.h>
|
||||
|
#endif
|
||||
|
|
||||
|
// faster than sscanf
|
||||
|
bool AsciiToHex(const char* _szValue, u32& result) |
||||
|
{ |
||||
|
char *endptr = NULL; |
||||
|
const u32 value = strtoul(_szValue, &endptr, 16); |
||||
|
|
||||
|
if (!endptr || *endptr) |
||||
|
return false; |
||||
|
|
||||
|
result = value; |
||||
|
return true; |
||||
|
} |
||||
|
|
||||
|
bool CharArrayFromFormatV(char* out, int outsize, const char* format, va_list args) |
||||
|
{ |
||||
|
int writtenCount; |
||||
|
|
||||
|
#ifdef _WIN32
|
||||
|
// You would think *printf are simple, right? Iterate on each character,
|
||||
|
// if it's a format specifier handle it properly, etc.
|
||||
|
//
|
||||
|
// Nooooo. Not according to the C standard.
|
||||
|
//
|
||||
|
// According to the C99 standard (7.19.6.1 "The fprintf function")
|
||||
|
// The format shall be a multibyte character sequence
|
||||
|
//
|
||||
|
// Because some character encodings might have '%' signs in the middle of
|
||||
|
// a multibyte sequence (SJIS for example only specifies that the first
|
||||
|
// byte of a 2 byte sequence is "high", the second byte can be anything),
|
||||
|
// printf functions have to decode the multibyte sequences and try their
|
||||
|
// best to not screw up.
|
||||
|
//
|
||||
|
// Unfortunately, on Windows, the locale for most languages is not UTF-8
|
||||
|
// as we would need. Notably, for zh_TW, Windows chooses EUC-CN as the
|
||||
|
// locale, and completely fails when trying to decode UTF-8 as EUC-CN.
|
||||
|
//
|
||||
|
// On the other hand, the fix is simple: because we use UTF-8, no such
|
||||
|
// multibyte handling is required as we can simply assume that no '%' char
|
||||
|
// will be present in the middle of a multibyte sequence.
|
||||
|
//
|
||||
|
// This is why we lookup an ANSI (cp1252) locale here and use _vsnprintf_l.
|
||||
|
static locale_t c_locale = NULL; |
||||
|
if (!c_locale) |
||||
|
c_locale = _create_locale(LC_ALL, ".1252"); |
||||
|
writtenCount = _vsnprintf_l(out, outsize, format, c_locale, args); |
||||
|
#else
|
||||
|
writtenCount = vsnprintf(out, outsize, format, args); |
||||
|
#endif
|
||||
|
|
||||
|
if (writtenCount > 0 && writtenCount < outsize) |
||||
|
{ |
||||
|
out[writtenCount] = '\0'; |
||||
|
return true; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
out[outsize - 1] = '\0'; |
||||
|
return false; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
std::string StringFromFormat(const char* format, ...) |
||||
|
{ |
||||
|
va_list args; |
||||
|
char *buf = NULL; |
||||
|
#ifdef _WIN32
|
||||
|
int required = 0; |
||||
|
|
||||
|
va_start(args, format); |
||||
|
required = _vscprintf(format, args); |
||||
|
buf = new char[required + 1]; |
||||
|
CharArrayFromFormatV(buf, required + 1, format, args); |
||||
|
va_end(args); |
||||
|
|
||||
|
std::string temp = buf; |
||||
|
delete[] buf; |
||||
|
#else
|
||||
|
va_start(args, format); |
||||
|
if (vasprintf(&buf, format, args) < 0) |
||||
|
ERROR_LOG(COMMON, "Unable to allocate memory for string"); |
||||
|
va_end(args); |
||||
|
|
||||
|
std::string temp = buf; |
||||
|
free(buf); |
||||
|
#endif
|
||||
|
return temp; |
||||
|
} |
||||
|
|
||||
|
// For Debugging. Read out an u8 array.
|
||||
|
std::string ArrayToString(const u8 *data, u32 size, int line_len, bool spaces) |
||||
|
{ |
||||
|
std::ostringstream oss; |
||||
|
oss << std::setfill('0') << std::hex; |
||||
|
|
||||
|
for (int line = 0; size; ++data, --size) |
||||
|
{ |
||||
|
oss << std::setw(2) << (int)*data; |
||||
|
|
||||
|
if (line_len == ++line) |
||||
|
{ |
||||
|
oss << '\n'; |
||||
|
line = 0; |
||||
|
} |
||||
|
else if (spaces) |
||||
|
oss << ' '; |
||||
|
} |
||||
|
|
||||
|
return oss.str(); |
||||
|
} |
||||
|
|
||||
|
// Turns " hej " into "hej". Also handles tabs.
|
||||
|
std::string StripSpaces(const std::string &str) |
||||
|
{ |
||||
|
const size_t s = str.find_first_not_of(" \t\r\n"); |
||||
|
|
||||
|
if (str.npos != s) |
||||
|
return str.substr(s, str.find_last_not_of(" \t\r\n") - s + 1); |
||||
|
else |
||||
|
return ""; |
||||
|
} |
||||
|
|
||||
|
// "\"hello\"" is turned to "hello"
|
||||
|
// This one assumes that the string has already been space stripped in both
|
||||
|
// ends, as done by StripSpaces above, for example.
|
||||
|
std::string StripQuotes(const std::string& s) |
||||
|
{ |
||||
|
if (s.size() && '\"' == s[0] && '\"' == *s.rbegin()) |
||||
|
return s.substr(1, s.size() - 2); |
||||
|
else |
||||
|
return s; |
||||
|
} |
||||
|
|
||||
|
bool TryParse(const std::string &str, u32 *const output) |
||||
|
{ |
||||
|
char *endptr = NULL; |
||||
|
|
||||
|
// Reset errno to a value other than ERANGE
|
||||
|
errno = 0; |
||||
|
|
||||
|
unsigned long value = strtoul(str.c_str(), &endptr, 0); |
||||
|
|
||||
|
if (!endptr || *endptr) |
||||
|
return false; |
||||
|
|
||||
|
if (errno == ERANGE) |
||||
|
return false; |
||||
|
|
||||
|
#if ULONG_MAX > UINT_MAX
|
||||
|
if (value >= 0x100000000ull |
||||
|
&& value <= 0xFFFFFFFF00000000ull) |
||||
|
return false; |
||||
|
#endif
|
||||
|
|
||||
|
*output = static_cast<u32>(value); |
||||
|
return true; |
||||
|
} |
||||
|
|
||||
|
bool TryParse(const std::string &str, bool *const output) |
||||
|
{ |
||||
|
if ("1" == str || !strcasecmp("true", str.c_str())) |
||||
|
*output = true; |
||||
|
else if ("0" == str || !strcasecmp("false", str.c_str())) |
||||
|
*output = false; |
||||
|
else |
||||
|
return false; |
||||
|
|
||||
|
return true; |
||||
|
} |
||||
|
|
||||
|
std::string StringFromInt(int value) |
||||
|
{ |
||||
|
char temp[16]; |
||||
|
sprintf(temp, "%i", value); |
||||
|
return temp; |
||||
|
} |
||||
|
|
||||
|
std::string StringFromBool(bool value) |
||||
|
{ |
||||
|
return value ? "True" : "False"; |
||||
|
} |
||||
|
|
||||
|
bool SplitPath(const std::string& full_path, std::string* _pPath, std::string* _pFilename, std::string* _pExtension) |
||||
|
{ |
||||
|
if (full_path.empty()) |
||||
|
return false; |
||||
|
|
||||
|
size_t dir_end = full_path.find_last_of("/" |
||||
|
// windows needs the : included for something like just "C:" to be considered a directory
|
||||
|
#ifdef _WIN32
|
||||
|
":" |
||||
|
#endif
|
||||
|
); |
||||
|
if (std::string::npos == dir_end) |
||||
|
dir_end = 0; |
||||
|
else |
||||
|
dir_end += 1; |
||||
|
|
||||
|
size_t fname_end = full_path.rfind('.'); |
||||
|
if (fname_end < dir_end || std::string::npos == fname_end) |
||||
|
fname_end = full_path.size(); |
||||
|
|
||||
|
if (_pPath) |
||||
|
*_pPath = full_path.substr(0, dir_end); |
||||
|
|
||||
|
if (_pFilename) |
||||
|
*_pFilename = full_path.substr(dir_end, fname_end - dir_end); |
||||
|
|
||||
|
if (_pExtension) |
||||
|
*_pExtension = full_path.substr(fname_end); |
||||
|
|
||||
|
return true; |
||||
|
} |
||||
|
|
||||
|
void BuildCompleteFilename(std::string& _CompleteFilename, const std::string& _Path, const std::string& _Filename) |
||||
|
{ |
||||
|
_CompleteFilename = _Path; |
||||
|
|
||||
|
// check for seperator
|
||||
|
if (DIR_SEP_CHR != *_CompleteFilename.rbegin()) |
||||
|
_CompleteFilename += DIR_SEP_CHR; |
||||
|
|
||||
|
// add the filename
|
||||
|
_CompleteFilename += _Filename; |
||||
|
} |
||||
|
|
||||
|
void SplitString(const std::string& str, const char delim, std::vector<std::string>& output) |
||||
|
{ |
||||
|
std::istringstream iss(str); |
||||
|
output.resize(1); |
||||
|
|
||||
|
while (std::getline(iss, *output.rbegin(), delim)) |
||||
|
output.push_back(""); |
||||
|
|
||||
|
output.pop_back(); |
||||
|
} |
||||
|
|
||||
|
std::string TabsToSpaces(int tab_size, const std::string &in) |
||||
|
{ |
||||
|
const std::string spaces(tab_size, ' '); |
||||
|
std::string out(in); |
||||
|
|
||||
|
size_t i = 0; |
||||
|
while (out.npos != (i = out.find('\t'))) |
||||
|
out.replace(i, 1, spaces); |
||||
|
|
||||
|
return out; |
||||
|
} |
||||
|
|
||||
|
std::string ReplaceAll(std::string result, const std::string& src, const std::string& dest) |
||||
|
{ |
||||
|
while(1) |
||||
|
{ |
||||
|
size_t pos = result.find(src); |
||||
|
if (pos == std::string::npos) break; |
||||
|
result.replace(pos, src.size(), dest); |
||||
|
} |
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
// UriDecode and UriEncode are from http://www.codeguru.com/cpp/cpp/string/conversions/print.php/c12759
|
||||
|
// by jinq0123 (November 2, 2006)
|
||||
|
|
||||
|
// Uri encode and decode.
|
||||
|
// RFC1630, RFC1738, RFC2396
|
||||
|
|
||||
|
//#include <string>
|
||||
|
//#include <assert.h>
|
||||
|
|
||||
|
const char HEX2DEC[256] = |
||||
|
{ |
||||
|
/* 0 1 2 3 4 5 6 7 8 9 A B C D E F */ |
||||
|
/* 0 */ 16,16,16,16, 16,16,16,16, 16,16,16,16, 16,16,16,16, |
||||
|
/* 1 */ 16,16,16,16, 16,16,16,16, 16,16,16,16, 16,16,16,16, |
||||
|
/* 2 */ 16,16,16,16, 16,16,16,16, 16,16,16,16, 16,16,16,16, |
||||
|
/* 3 */ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,16,16, 16,16,16,16, |
||||
|
|
||||
|
/* 4 */ 16,10,11,12, 13,14,15,16, 16,16,16,16, 16,16,16,16, |
||||
|
/* 5 */ 16,16,16,16, 16,16,16,16, 16,16,16,16, 16,16,16,16, |
||||
|
/* 6 */ 16,10,11,12, 13,14,15,16, 16,16,16,16, 16,16,16,16, |
||||
|
/* 7 */ 16,16,16,16, 16,16,16,16, 16,16,16,16, 16,16,16,16, |
||||
|
|
||||
|
/* 8 */ 16,16,16,16, 16,16,16,16, 16,16,16,16, 16,16,16,16, |
||||
|
/* 9 */ 16,16,16,16, 16,16,16,16, 16,16,16,16, 16,16,16,16, |
||||
|
/* A */ 16,16,16,16, 16,16,16,16, 16,16,16,16, 16,16,16,16, |
||||
|
/* B */ 16,16,16,16, 16,16,16,16, 16,16,16,16, 16,16,16,16, |
||||
|
|
||||
|
/* C */ 16,16,16,16, 16,16,16,16, 16,16,16,16, 16,16,16,16, |
||||
|
/* D */ 16,16,16,16, 16,16,16,16, 16,16,16,16, 16,16,16,16, |
||||
|
/* E */ 16,16,16,16, 16,16,16,16, 16,16,16,16, 16,16,16,16, |
||||
|
/* F */ 16,16,16,16, 16,16,16,16, 16,16,16,16, 16,16,16,16 |
||||
|
}; |
||||
|
|
||||
|
std::string UriDecode(const std::string & sSrc) |
||||
|
{ |
||||
|
// Note from RFC1630: "Sequences which start with a percent sign
|
||||
|
// but are not followed by two hexadecimal characters (0-9, A-F) are reserved
|
||||
|
// for future extension"
|
||||
|
|
||||
|
const unsigned char * pSrc = (const unsigned char *)sSrc.c_str(); |
||||
|
const size_t SRC_LEN = sSrc.length(); |
||||
|
const unsigned char * const SRC_END = pSrc + SRC_LEN; |
||||
|
const unsigned char * const SRC_LAST_DEC = SRC_END - 2; // last decodable '%'
|
||||
|
|
||||
|
char * const pStart = new char[SRC_LEN]; |
||||
|
char * pEnd = pStart; |
||||
|
|
||||
|
while (pSrc < SRC_LAST_DEC) |
||||
|
{ |
||||
|
if (*pSrc == '%') |
||||
|
{ |
||||
|
char dec1, dec2; |
||||
|
if (16 != (dec1 = HEX2DEC[*(pSrc + 1)]) |
||||
|
&& 16 != (dec2 = HEX2DEC[*(pSrc + 2)])) |
||||
|
{ |
||||
|
*pEnd++ = (dec1 << 4) + dec2; |
||||
|
pSrc += 3; |
||||
|
continue; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
*pEnd++ = *pSrc++; |
||||
|
} |
||||
|
|
||||
|
// the last 2- chars
|
||||
|
while (pSrc < SRC_END) |
||||
|
*pEnd++ = *pSrc++; |
||||
|
|
||||
|
std::string sResult(pStart, pEnd); |
||||
|
delete [] pStart; |
||||
|
return sResult; |
||||
|
} |
||||
|
|
||||
|
// Only alphanum is safe.
|
||||
|
const char SAFE[256] = |
||||
|
{ |
||||
|
/* 0 1 2 3 4 5 6 7 8 9 A B C D E F */ |
||||
|
/* 0 */ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, |
||||
|
/* 1 */ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, |
||||
|
/* 2 */ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, |
||||
|
/* 3 */ 1,1,1,1, 1,1,1,1, 1,1,0,0, 0,0,0,0, |
||||
|
|
||||
|
/* 4 */ 0,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1, |
||||
|
/* 5 */ 1,1,1,1, 1,1,1,1, 1,1,1,0, 0,0,0,0, |
||||
|
/* 6 */ 0,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1, |
||||
|
/* 7 */ 1,1,1,1, 1,1,1,1, 1,1,1,0, 0,0,0,0, |
||||
|
|
||||
|
/* 8 */ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, |
||||
|
/* 9 */ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, |
||||
|
/* A */ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, |
||||
|
/* B */ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, |
||||
|
|
||||
|
/* C */ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, |
||||
|
/* D */ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, |
||||
|
/* E */ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, |
||||
|
/* F */ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0 |
||||
|
}; |
||||
|
|
||||
|
std::string UriEncode(const std::string & sSrc) |
||||
|
{ |
||||
|
const char DEC2HEX[16 + 1] = "0123456789ABCDEF"; |
||||
|
const unsigned char * pSrc = (const unsigned char *)sSrc.c_str(); |
||||
|
const size_t SRC_LEN = sSrc.length(); |
||||
|
unsigned char * const pStart = new unsigned char[SRC_LEN * 3]; |
||||
|
unsigned char * pEnd = pStart; |
||||
|
const unsigned char * const SRC_END = pSrc + SRC_LEN; |
||||
|
|
||||
|
for (; pSrc < SRC_END; ++pSrc) |
||||
|
{ |
||||
|
if (SAFE[*pSrc]) |
||||
|
*pEnd++ = *pSrc; |
||||
|
else |
||||
|
{ |
||||
|
// escape this char
|
||||
|
*pEnd++ = '%'; |
||||
|
*pEnd++ = DEC2HEX[*pSrc >> 4]; |
||||
|
*pEnd++ = DEC2HEX[*pSrc & 0x0F]; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
std::string sResult((char *)pStart, (char *)pEnd); |
||||
|
delete [] pStart; |
||||
|
return sResult; |
||||
|
} |
||||
|
|
||||
|
#ifdef _WIN32
|
||||
|
|
||||
|
std::string UTF16ToUTF8(const std::wstring& input) |
||||
|
{ |
||||
|
auto const size = WideCharToMultiByte(CP_UTF8, 0, input.data(), input.size(), nullptr, 0, nullptr, nullptr); |
||||
|
|
||||
|
std::string output; |
||||
|
output.resize(size); |
||||
|
|
||||
|
if (size == 0 || size != WideCharToMultiByte(CP_UTF8, 0, input.data(), input.size(), &output[0], output.size(), nullptr, nullptr)) |
||||
|
output.clear(); |
||||
|
|
||||
|
return output; |
||||
|
} |
||||
|
|
||||
|
std::wstring CPToUTF16(u32 code_page, const std::string& input) |
||||
|
{ |
||||
|
auto const size = MultiByteToWideChar(code_page, 0, input.data(), input.size(), nullptr, 0); |
||||
|
|
||||
|
std::wstring output; |
||||
|
output.resize(size); |
||||
|
|
||||
|
if (size == 0 || size != MultiByteToWideChar(code_page, 0, input.data(), input.size(), &output[0], output.size())) |
||||
|
output.clear(); |
||||
|
|
||||
|
return output; |
||||
|
} |
||||
|
|
||||
|
std::wstring UTF8ToUTF16(const std::string& input) |
||||
|
{ |
||||
|
return CPToUTF16(CP_UTF8, input); |
||||
|
} |
||||
|
|
||||
|
std::string SHIFTJISToUTF8(const std::string& input) |
||||
|
{ |
||||
|
return UTF16ToUTF8(CPToUTF16(932, input)); |
||||
|
} |
||||
|
|
||||
|
std::string CP1252ToUTF8(const std::string& input) |
||||
|
{ |
||||
|
return UTF16ToUTF8(CPToUTF16(1252, input)); |
||||
|
} |
||||
|
|
||||
|
#else
|
||||
|
|
||||
|
template <typename T> |
||||
|
std::string CodeToUTF8(const char* fromcode, const std::basic_string<T>& input) |
||||
|
{ |
||||
|
std::string result; |
||||
|
|
||||
|
iconv_t const conv_desc = iconv_open("UTF-8", fromcode); |
||||
|
if ((iconv_t)-1 == conv_desc) |
||||
|
{ |
||||
|
ERROR_LOG(COMMON, "Iconv initialization failure [%s]: %s", fromcode, strerror(errno)); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
size_t const in_bytes = sizeof(T) * input.size(); |
||||
|
size_t const out_buffer_size = 4 * in_bytes; |
||||
|
|
||||
|
std::string out_buffer; |
||||
|
out_buffer.resize(out_buffer_size); |
||||
|
|
||||
|
auto src_buffer = &input[0]; |
||||
|
size_t src_bytes = in_bytes; |
||||
|
auto dst_buffer = &out_buffer[0]; |
||||
|
size_t dst_bytes = out_buffer.size(); |
||||
|
|
||||
|
while (src_bytes != 0) |
||||
|
{ |
||||
|
size_t const iconv_result = iconv(conv_desc, (char**)(&src_buffer), &src_bytes, |
||||
|
&dst_buffer, &dst_bytes); |
||||
|
|
||||
|
if ((size_t)-1 == iconv_result) |
||||
|
{ |
||||
|
if (EILSEQ == errno || EINVAL == errno) |
||||
|
{ |
||||
|
// Try to skip the bad character
|
||||
|
if (src_bytes != 0) |
||||
|
{ |
||||
|
--src_bytes; |
||||
|
++src_buffer; |
||||
|
} |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
ERROR_LOG(COMMON, "iconv failure [%s]: %s", fromcode, strerror(errno)); |
||||
|
break; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
out_buffer.resize(out_buffer_size - dst_bytes); |
||||
|
out_buffer.swap(result); |
||||
|
|
||||
|
iconv_close(conv_desc); |
||||
|
} |
||||
|
|
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
std::string CP1252ToUTF8(const std::string& input) |
||||
|
{ |
||||
|
//return CodeToUTF8("CP1252//TRANSLIT", input);
|
||||
|
//return CodeToUTF8("CP1252//IGNORE", input);
|
||||
|
return CodeToUTF8("CP1252", input); |
||||
|
} |
||||
|
|
||||
|
std::string SHIFTJISToUTF8(const std::string& input) |
||||
|
{ |
||||
|
//return CodeToUTF8("CP932", input);
|
||||
|
return CodeToUTF8("SJIS", input); |
||||
|
} |
||||
|
|
||||
|
std::string UTF16ToUTF8(const std::wstring& input) |
||||
|
{ |
||||
|
std::string result = |
||||
|
// CodeToUTF8("UCS-2", input);
|
||||
|
// CodeToUTF8("UCS-2LE", input);
|
||||
|
// CodeToUTF8("UTF-16", input);
|
||||
|
CodeToUTF8("UTF-16LE", input); |
||||
|
|
||||
|
// TODO: why is this needed?
|
||||
|
result.erase(std::remove(result.begin(), result.end(), 0x00), result.end()); |
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
#endif
|
||||
@ -0,0 +1,111 @@ |
|||||
|
// Copyright 2013 Dolphin Emulator Project |
||||
|
// Licensed under GPLv2 |
||||
|
// Refer to the license.txt file included. |
||||
|
|
||||
|
#ifndef _STRINGUTIL_H_ |
||||
|
#define _STRINGUTIL_H_ |
||||
|
|
||||
|
#include <stdarg.h> |
||||
|
|
||||
|
#include <vector> |
||||
|
#include <string> |
||||
|
#include <sstream> |
||||
|
#include <iomanip> |
||||
|
|
||||
|
#include "common.h" |
||||
|
|
||||
|
std::string StringFromFormat(const char* format, ...); |
||||
|
// Cheap! |
||||
|
bool CharArrayFromFormatV(char* out, int outsize, const char* format, va_list args); |
||||
|
|
||||
|
template<size_t Count> |
||||
|
inline void CharArrayFromFormat(char (& out)[Count], const char* format, ...) |
||||
|
{ |
||||
|
va_list args; |
||||
|
va_start(args, format); |
||||
|
CharArrayFromFormatV(out, Count, format, args); |
||||
|
va_end(args); |
||||
|
} |
||||
|
|
||||
|
// Good |
||||
|
std::string ArrayToString(const u8 *data, u32 size, int line_len = 20, bool spaces = true); |
||||
|
|
||||
|
std::string StripSpaces(const std::string &s); |
||||
|
std::string StripQuotes(const std::string &s); |
||||
|
|
||||
|
// Thousand separator. Turns 12345678 into 12,345,678 |
||||
|
template <typename I> |
||||
|
std::string ThousandSeparate(I value, int spaces = 0) |
||||
|
{ |
||||
|
std::ostringstream oss; |
||||
|
|
||||
|
// std::locale("") seems to be broken on many platforms |
||||
|
#if defined _WIN32 || (defined __linux__ && !defined __clang__) |
||||
|
oss.imbue(std::locale("")); |
||||
|
#endif |
||||
|
oss << std::setw(spaces) << value; |
||||
|
|
||||
|
return oss.str(); |
||||
|
} |
||||
|
|
||||
|
std::string StringFromInt(int value); |
||||
|
std::string StringFromBool(bool value); |
||||
|
|
||||
|
bool TryParse(const std::string &str, bool *output); |
||||
|
bool TryParse(const std::string &str, u32 *output); |
||||
|
|
||||
|
template <typename N> |
||||
|
static bool TryParse(const std::string &str, N *const output) |
||||
|
{ |
||||
|
std::istringstream iss(str); |
||||
|
|
||||
|
N tmp = 0; |
||||
|
if (iss >> tmp) |
||||
|
{ |
||||
|
*output = tmp; |
||||
|
return true; |
||||
|
} |
||||
|
else |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
// TODO: kill this |
||||
|
bool AsciiToHex(const char* _szValue, u32& result); |
||||
|
|
||||
|
std::string TabsToSpaces(int tab_size, const std::string &in); |
||||
|
|
||||
|
void SplitString(const std::string& str, char delim, std::vector<std::string>& output); |
||||
|
|
||||
|
// "C:/Windows/winhelp.exe" to "C:/Windows/", "winhelp", ".exe" |
||||
|
bool SplitPath(const std::string& full_path, std::string* _pPath, std::string* _pFilename, std::string* _pExtension); |
||||
|
|
||||
|
void BuildCompleteFilename(std::string& _CompleteFilename, const std::string& _Path, const std::string& _Filename); |
||||
|
std::string ReplaceAll(std::string result, const std::string& src, const std::string& dest); |
||||
|
std::string UriDecode(const std::string & sSrc); |
||||
|
std::string UriEncode(const std::string & sSrc); |
||||
|
|
||||
|
std::string CP1252ToUTF8(const std::string& str); |
||||
|
std::string SHIFTJISToUTF8(const std::string& str); |
||||
|
std::string UTF16ToUTF8(const std::wstring& str); |
||||
|
|
||||
|
#ifdef _WIN32 |
||||
|
|
||||
|
std::wstring UTF8ToUTF16(const std::string& str); |
||||
|
|
||||
|
#ifdef _UNICODE |
||||
|
inline std::string TStrToUTF8(const std::wstring& str) |
||||
|
{ return UTF16ToUTF8(str); } |
||||
|
|
||||
|
inline std::wstring UTF8ToTStr(const std::string& str) |
||||
|
{ return UTF8ToUTF16(str); } |
||||
|
#else |
||||
|
inline std::string TStrToUTF8(const std::string& str) |
||||
|
{ return str; } |
||||
|
|
||||
|
inline std::string UTF8ToTStr(const std::string& str) |
||||
|
{ return str; } |
||||
|
#endif |
||||
|
|
||||
|
#endif |
||||
|
|
||||
|
#endif // _STRINGUTIL_H_ |
||||
@ -0,0 +1,133 @@ |
|||||
|
// Copyright 2013 Dolphin Emulator Project
|
||||
|
// Licensed under GPLv2
|
||||
|
// Refer to the license.txt file included.
|
||||
|
|
||||
|
#include "thread.h"
|
||||
|
#include "common.h"
|
||||
|
|
||||
|
#ifdef __APPLE__
|
||||
|
#include <mach/mach.h>
|
||||
|
#elif defined BSD4_4
|
||||
|
#include <pthread_np.h>
|
||||
|
#endif
|
||||
|
|
||||
|
#ifdef USE_BEGINTHREADEX
|
||||
|
#include <process.h>
|
||||
|
#endif
|
||||
|
|
||||
|
namespace Common |
||||
|
{ |
||||
|
|
||||
|
int CurrentThreadId() |
||||
|
{ |
||||
|
#ifdef _WIN32
|
||||
|
return GetCurrentThreadId(); |
||||
|
#elif defined __APPLE__
|
||||
|
return mach_thread_self(); |
||||
|
#else
|
||||
|
return 0; |
||||
|
#endif
|
||||
|
} |
||||
|
|
||||
|
#ifdef _WIN32
|
||||
|
|
||||
|
void SetThreadAffinity(std::thread::native_handle_type thread, u32 mask) |
||||
|
{ |
||||
|
SetThreadAffinityMask(thread, mask); |
||||
|
} |
||||
|
|
||||
|
void SetCurrentThreadAffinity(u32 mask) |
||||
|
{ |
||||
|
SetThreadAffinityMask(GetCurrentThread(), mask); |
||||
|
} |
||||
|
|
||||
|
// Supporting functions
|
||||
|
void SleepCurrentThread(int ms) |
||||
|
{ |
||||
|
Sleep(ms); |
||||
|
} |
||||
|
|
||||
|
void SwitchCurrentThread() |
||||
|
{ |
||||
|
SwitchToThread(); |
||||
|
} |
||||
|
|
||||
|
// Sets the debugger-visible name of the current thread.
|
||||
|
// Uses undocumented (actually, it is now documented) trick.
|
||||
|
// http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vsdebug/html/vxtsksettingthreadname.asp
|
||||
|
|
||||
|
// This is implemented much nicer in upcoming msvc++, see:
|
||||
|
// http://msdn.microsoft.com/en-us/library/xcb2z8hs(VS.100).aspx
|
||||
|
void SetCurrentThreadName(const char* szThreadName) |
||||
|
{ |
||||
|
static const DWORD MS_VC_EXCEPTION = 0x406D1388; |
||||
|
|
||||
|
#pragma pack(push,8)
|
||||
|
struct THREADNAME_INFO |
||||
|
{ |
||||
|
DWORD dwType; // must be 0x1000
|
||||
|
LPCSTR szName; // pointer to name (in user addr space)
|
||||
|
DWORD dwThreadID; // thread ID (-1=caller thread)
|
||||
|
DWORD dwFlags; // reserved for future use, must be zero
|
||||
|
} info; |
||||
|
#pragma pack(pop)
|
||||
|
|
||||
|
info.dwType = 0x1000; |
||||
|
info.szName = szThreadName; |
||||
|
info.dwThreadID = -1; //dwThreadID;
|
||||
|
info.dwFlags = 0; |
||||
|
|
||||
|
__try |
||||
|
{ |
||||
|
RaiseException(MS_VC_EXCEPTION, 0, sizeof(info)/sizeof(ULONG_PTR), (ULONG_PTR*)&info); |
||||
|
} |
||||
|
__except(EXCEPTION_CONTINUE_EXECUTION) |
||||
|
{} |
||||
|
} |
||||
|
|
||||
|
#else // !WIN32, so must be POSIX threads
|
||||
|
|
||||
|
void SetThreadAffinity(std::thread::native_handle_type thread, u32 mask) |
||||
|
{ |
||||
|
#ifdef __APPLE__
|
||||
|
thread_policy_set(pthread_mach_thread_np(thread), |
||||
|
THREAD_AFFINITY_POLICY, (integer_t *)&mask, 1); |
||||
|
#elif (defined __linux__ || defined BSD4_4) && !(defined ANDROID)
|
||||
|
cpu_set_t cpu_set; |
||||
|
CPU_ZERO(&cpu_set); |
||||
|
|
||||
|
for (int i = 0; i != sizeof(mask) * 8; ++i) |
||||
|
if ((mask >> i) & 1) |
||||
|
CPU_SET(i, &cpu_set); |
||||
|
|
||||
|
pthread_setaffinity_np(thread, sizeof(cpu_set), &cpu_set); |
||||
|
#endif
|
||||
|
} |
||||
|
|
||||
|
void SetCurrentThreadAffinity(u32 mask) |
||||
|
{ |
||||
|
SetThreadAffinity(pthread_self(), mask); |
||||
|
} |
||||
|
|
||||
|
void SleepCurrentThread(int ms) |
||||
|
{ |
||||
|
usleep(1000 * ms); |
||||
|
} |
||||
|
|
||||
|
void SwitchCurrentThread() |
||||
|
{ |
||||
|
usleep(1000 * 1); |
||||
|
} |
||||
|
|
||||
|
void SetCurrentThreadName(const char* szThreadName) |
||||
|
{ |
||||
|
#ifdef __APPLE__
|
||||
|
pthread_setname_np(szThreadName); |
||||
|
#else
|
||||
|
pthread_setname_np(pthread_self(), szThreadName); |
||||
|
#endif
|
||||
|
} |
||||
|
|
||||
|
#endif
|
||||
|
|
||||
|
} // namespace Common
|
||||
@ -0,0 +1,156 @@ |
|||||
|
// Copyright 2013 Dolphin Emulator Project |
||||
|
// Licensed under GPLv2 |
||||
|
// Refer to the license.txt file included. |
||||
|
|
||||
|
#ifndef _THREAD_H_ |
||||
|
#define _THREAD_H_ |
||||
|
|
||||
|
#include "std_condition_variable.h" |
||||
|
#include "std_mutex.h" |
||||
|
#include "std_thread.h" |
||||
|
|
||||
|
// Don't include common.h here as it will break LogManager |
||||
|
#include "common_types.h" |
||||
|
#include <stdio.h> |
||||
|
#include <string.h> |
||||
|
|
||||
|
// This may not be defined outside _WIN32 |
||||
|
#ifndef _WIN32 |
||||
|
#ifndef INFINITE |
||||
|
#define INFINITE 0xffffffff |
||||
|
#endif |
||||
|
|
||||
|
//for gettimeofday and struct time(spec|val) |
||||
|
#include <time.h> |
||||
|
#include <sys/time.h> |
||||
|
#endif |
||||
|
|
||||
|
namespace Common |
||||
|
{ |
||||
|
|
||||
|
int CurrentThreadId(); |
||||
|
|
||||
|
void SetThreadAffinity(std::thread::native_handle_type thread, u32 mask); |
||||
|
void SetCurrentThreadAffinity(u32 mask); |
||||
|
|
||||
|
class Event |
||||
|
{ |
||||
|
public: |
||||
|
Event() |
||||
|
: is_set(false) |
||||
|
{}; |
||||
|
|
||||
|
void Set() |
||||
|
{ |
||||
|
std::lock_guard<std::mutex> lk(m_mutex); |
||||
|
if (!is_set) |
||||
|
{ |
||||
|
is_set = true; |
||||
|
m_condvar.notify_one(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
void Wait() |
||||
|
{ |
||||
|
std::unique_lock<std::mutex> lk(m_mutex); |
||||
|
m_condvar.wait(lk, IsSet(this)); |
||||
|
is_set = false; |
||||
|
} |
||||
|
|
||||
|
void Reset() |
||||
|
{ |
||||
|
std::unique_lock<std::mutex> lk(m_mutex); |
||||
|
// no other action required, since wait loops on the predicate and any lingering signal will get cleared on the first iteration |
||||
|
is_set = false; |
||||
|
} |
||||
|
|
||||
|
private: |
||||
|
class IsSet |
||||
|
{ |
||||
|
public: |
||||
|
IsSet(const Event* ev) |
||||
|
: m_event(ev) |
||||
|
{} |
||||
|
|
||||
|
bool operator()() |
||||
|
{ |
||||
|
return m_event->is_set; |
||||
|
} |
||||
|
|
||||
|
private: |
||||
|
const Event* const m_event; |
||||
|
}; |
||||
|
|
||||
|
volatile bool is_set; |
||||
|
std::condition_variable m_condvar; |
||||
|
std::mutex m_mutex; |
||||
|
}; |
||||
|
|
||||
|
// TODO: doesn't work on windows with (count > 2) |
||||
|
class Barrier |
||||
|
{ |
||||
|
public: |
||||
|
Barrier(size_t count) |
||||
|
: m_count(count), m_waiting(0) |
||||
|
{} |
||||
|
|
||||
|
// block until "count" threads call Sync() |
||||
|
bool Sync() |
||||
|
{ |
||||
|
std::unique_lock<std::mutex> lk(m_mutex); |
||||
|
|
||||
|
// TODO: broken when next round of Sync()s |
||||
|
// is entered before all waiting threads return from the notify_all |
||||
|
|
||||
|
if (m_count == ++m_waiting) |
||||
|
{ |
||||
|
m_waiting = 0; |
||||
|
m_condvar.notify_all(); |
||||
|
return true; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
m_condvar.wait(lk, IsDoneWating(this)); |
||||
|
return false; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private: |
||||
|
class IsDoneWating |
||||
|
{ |
||||
|
public: |
||||
|
IsDoneWating(const Barrier* bar) |
||||
|
: m_bar(bar) |
||||
|
{} |
||||
|
|
||||
|
bool operator()() |
||||
|
{ |
||||
|
return (0 == m_bar->m_waiting); |
||||
|
} |
||||
|
|
||||
|
private: |
||||
|
const Barrier* const m_bar; |
||||
|
}; |
||||
|
|
||||
|
std::condition_variable m_condvar; |
||||
|
std::mutex m_mutex; |
||||
|
const size_t m_count; |
||||
|
volatile size_t m_waiting; |
||||
|
}; |
||||
|
|
||||
|
void SleepCurrentThread(int ms); |
||||
|
void SwitchCurrentThread(); // On Linux, this is equal to sleep 1ms |
||||
|
|
||||
|
// Use this function during a spin-wait to make the current thread |
||||
|
// relax while another thread is working. This may be more efficient |
||||
|
// than using events because event functions use kernel calls. |
||||
|
inline void YieldCPU() |
||||
|
{ |
||||
|
std::this_thread::yield(); |
||||
|
} |
||||
|
|
||||
|
void SetCurrentThreadName(const char *name); |
||||
|
|
||||
|
} // namespace Common |
||||
|
|
||||
|
#endif // _THREAD_H_ |
||||
@ -0,0 +1,46 @@ |
|||||
|
// Copyright 2013 Dolphin Emulator Project |
||||
|
// Licensed under GPLv2 |
||||
|
// Refer to the license.txt file included. |
||||
|
|
||||
|
#ifndef _THUNK_H_ |
||||
|
#define _THUNK_H_ |
||||
|
|
||||
|
#include <map> |
||||
|
|
||||
|
#include "common.h" |
||||
|
#include "x64Emitter.h" |
||||
|
|
||||
|
// This simple class creates a wrapper around a C/C++ function that saves all fp state |
||||
|
// before entering it, and restores it upon exit. This is required to be able to selectively |
||||
|
// call functions from generated code, without inflicting the performance hit and increase |
||||
|
// of complexity that it means to protect the generated code from this problem. |
||||
|
|
||||
|
// This process is called thunking. |
||||
|
|
||||
|
// There will only ever be one level of thunking on the stack, plus, |
||||
|
// we don't want to pollute the stack, so we store away regs somewhere global. |
||||
|
// NOT THREAD SAFE. This may only be used from the CPU thread. |
||||
|
// Any other thread using this stuff will be FATAL. |
||||
|
|
||||
|
class ThunkManager : public Gen::XCodeBlock |
||||
|
{ |
||||
|
std::map<void *, const u8 *> thunks; |
||||
|
|
||||
|
const u8 *save_regs; |
||||
|
const u8 *load_regs; |
||||
|
|
||||
|
public: |
||||
|
ThunkManager() { |
||||
|
Init(); |
||||
|
} |
||||
|
~ThunkManager() { |
||||
|
Shutdown(); |
||||
|
} |
||||
|
void *ProtectFunction(void *function, int num_params); |
||||
|
private: |
||||
|
void Init(); |
||||
|
void Shutdown(); |
||||
|
void Reset(); |
||||
|
}; |
||||
|
|
||||
|
#endif // _THUNK_H_ |
||||
@ -0,0 +1,226 @@ |
|||||
|
// Copyright 2013 Dolphin Emulator Project
|
||||
|
// Licensed under GPLv2
|
||||
|
// Refer to the license.txt file included.
|
||||
|
|
||||
|
#include <time.h>
|
||||
|
|
||||
|
#ifdef _WIN32
|
||||
|
#include <Windows.h>
|
||||
|
#include <mmsystem.h>
|
||||
|
#include <sys/timeb.h>
|
||||
|
#else
|
||||
|
#include <sys/time.h>
|
||||
|
#endif
|
||||
|
|
||||
|
#include "common.h"
|
||||
|
#include "timer.h"
|
||||
|
#include "string_util.h"
|
||||
|
|
||||
|
namespace Common |
||||
|
{ |
||||
|
|
||||
|
u32 Timer::GetTimeMs() |
||||
|
{ |
||||
|
#ifdef _WIN32
|
||||
|
return timeGetTime(); |
||||
|
#else
|
||||
|
struct timeval t; |
||||
|
(void)gettimeofday(&t, NULL); |
||||
|
return ((u32)(t.tv_sec * 1000 + t.tv_usec / 1000)); |
||||
|
#endif
|
||||
|
} |
||||
|
|
||||
|
// --------------------------------------------
|
||||
|
// Initiate, Start, Stop, and Update the time
|
||||
|
// --------------------------------------------
|
||||
|
|
||||
|
// Set initial values for the class
|
||||
|
Timer::Timer() |
||||
|
: m_LastTime(0), m_StartTime(0), m_Running(false) |
||||
|
{ |
||||
|
Update(); |
||||
|
} |
||||
|
|
||||
|
// Write the starting time
|
||||
|
void Timer::Start() |
||||
|
{ |
||||
|
m_StartTime = GetTimeMs(); |
||||
|
m_Running = true; |
||||
|
} |
||||
|
|
||||
|
// Stop the timer
|
||||
|
void Timer::Stop() |
||||
|
{ |
||||
|
// Write the final time
|
||||
|
m_LastTime = GetTimeMs(); |
||||
|
m_Running = false; |
||||
|
} |
||||
|
|
||||
|
// Update the last time variable
|
||||
|
void Timer::Update() |
||||
|
{ |
||||
|
m_LastTime = GetTimeMs(); |
||||
|
//TODO(ector) - QPF
|
||||
|
} |
||||
|
|
||||
|
// -------------------------------------
|
||||
|
// Get time difference and elapsed time
|
||||
|
// -------------------------------------
|
||||
|
|
||||
|
// Get the number of milliseconds since the last Update()
|
||||
|
u64 Timer::GetTimeDifference() |
||||
|
{ |
||||
|
return GetTimeMs() - m_LastTime; |
||||
|
} |
||||
|
|
||||
|
// Add the time difference since the last Update() to the starting time.
|
||||
|
// This is used to compensate for a paused game.
|
||||
|
void Timer::AddTimeDifference() |
||||
|
{ |
||||
|
m_StartTime += GetTimeDifference(); |
||||
|
} |
||||
|
|
||||
|
// Get the time elapsed since the Start()
|
||||
|
u64 Timer::GetTimeElapsed() |
||||
|
{ |
||||
|
// If we have not started yet, return 1 (because then I don't
|
||||
|
// have to change the FPS calculation in CoreRerecording.cpp .
|
||||
|
if (m_StartTime == 0) return 1; |
||||
|
|
||||
|
// Return the final timer time if the timer is stopped
|
||||
|
if (!m_Running) return (m_LastTime - m_StartTime); |
||||
|
|
||||
|
return (GetTimeMs() - m_StartTime); |
||||
|
} |
||||
|
|
||||
|
// Get the formatted time elapsed since the Start()
|
||||
|
std::string Timer::GetTimeElapsedFormatted() const |
||||
|
{ |
||||
|
// If we have not started yet, return zero
|
||||
|
if (m_StartTime == 0) |
||||
|
return "00:00:00:000"; |
||||
|
|
||||
|
// The number of milliseconds since the start.
|
||||
|
// Use a different value if the timer is stopped.
|
||||
|
u64 Milliseconds; |
||||
|
if (m_Running) |
||||
|
Milliseconds = GetTimeMs() - m_StartTime; |
||||
|
else |
||||
|
Milliseconds = m_LastTime - m_StartTime; |
||||
|
// Seconds
|
||||
|
u32 Seconds = (u32)(Milliseconds / 1000); |
||||
|
// Minutes
|
||||
|
u32 Minutes = Seconds / 60; |
||||
|
// Hours
|
||||
|
u32 Hours = Minutes / 60; |
||||
|
|
||||
|
std::string TmpStr = StringFromFormat("%02i:%02i:%02i:%03i", |
||||
|
Hours, Minutes % 60, Seconds % 60, Milliseconds % 1000); |
||||
|
return TmpStr; |
||||
|
} |
||||
|
|
||||
|
// Get current time
|
||||
|
void Timer::IncreaseResolution() |
||||
|
{ |
||||
|
#ifdef _WIN32
|
||||
|
timeBeginPeriod(1); |
||||
|
#endif
|
||||
|
} |
||||
|
|
||||
|
void Timer::RestoreResolution() |
||||
|
{ |
||||
|
#ifdef _WIN32
|
||||
|
timeEndPeriod(1); |
||||
|
#endif
|
||||
|
} |
||||
|
|
||||
|
// Get the number of seconds since January 1 1970
|
||||
|
u64 Timer::GetTimeSinceJan1970() |
||||
|
{ |
||||
|
time_t ltime; |
||||
|
time(<ime); |
||||
|
return((u64)ltime); |
||||
|
} |
||||
|
|
||||
|
u64 Timer::GetLocalTimeSinceJan1970() |
||||
|
{ |
||||
|
time_t sysTime, tzDiff, tzDST; |
||||
|
struct tm * gmTime; |
||||
|
|
||||
|
time(&sysTime); |
||||
|
|
||||
|
// Account for DST where needed
|
||||
|
gmTime = localtime(&sysTime); |
||||
|
if(gmTime->tm_isdst == 1) |
||||
|
tzDST = 3600; |
||||
|
else |
||||
|
tzDST = 0; |
||||
|
|
||||
|
// Lazy way to get local time in sec
|
||||
|
gmTime = gmtime(&sysTime); |
||||
|
tzDiff = sysTime - mktime(gmTime); |
||||
|
|
||||
|
return (u64)(sysTime + tzDiff + tzDST); |
||||
|
} |
||||
|
|
||||
|
// Return the current time formatted as Minutes:Seconds:Milliseconds
|
||||
|
// in the form 00:00:000.
|
||||
|
std::string Timer::GetTimeFormatted() |
||||
|
{ |
||||
|
time_t sysTime; |
||||
|
struct tm * gmTime; |
||||
|
char formattedTime[13]; |
||||
|
char tmp[13]; |
||||
|
|
||||
|
time(&sysTime); |
||||
|
gmTime = localtime(&sysTime); |
||||
|
|
||||
|
strftime(tmp, 6, "%M:%S", gmTime); |
||||
|
|
||||
|
// Now tack on the milliseconds
|
||||
|
#ifdef _WIN32
|
||||
|
struct timeb tp; |
||||
|
(void)::ftime(&tp); |
||||
|
sprintf(formattedTime, "%s:%03i", tmp, tp.millitm); |
||||
|
#else
|
||||
|
struct timeval t; |
||||
|
(void)gettimeofday(&t, NULL); |
||||
|
sprintf(formattedTime, "%s:%03d", tmp, (int)(t.tv_usec / 1000)); |
||||
|
#endif
|
||||
|
|
||||
|
return std::string(formattedTime); |
||||
|
} |
||||
|
|
||||
|
// Returns a timestamp with decimals for precise time comparisons
|
||||
|
// ----------------
|
||||
|
double Timer::GetDoubleTime() |
||||
|
{ |
||||
|
#ifdef _WIN32
|
||||
|
struct timeb tp; |
||||
|
(void)::ftime(&tp); |
||||
|
#else
|
||||
|
struct timeval t; |
||||
|
(void)gettimeofday(&t, NULL); |
||||
|
#endif
|
||||
|
// Get continuous timestamp
|
||||
|
u64 TmpSeconds = Common::Timer::GetTimeSinceJan1970(); |
||||
|
|
||||
|
// Remove a few years. We only really want enough seconds to make
|
||||
|
// sure that we are detecting actual actions, perhaps 60 seconds is
|
||||
|
// enough really, but I leave a year of seconds anyway, in case the
|
||||
|
// user's clock is incorrect or something like that.
|
||||
|
TmpSeconds = TmpSeconds - (38 * 365 * 24 * 60 * 60); |
||||
|
|
||||
|
// Make a smaller integer that fits in the double
|
||||
|
u32 Seconds = (u32)TmpSeconds; |
||||
|
#ifdef _WIN32
|
||||
|
double ms = tp.millitm / 1000.0 / 1000.0; |
||||
|
#else
|
||||
|
double ms = t.tv_usec / 1000000.0; |
||||
|
#endif
|
||||
|
double TmpTime = Seconds + ms; |
||||
|
|
||||
|
return TmpTime; |
||||
|
} |
||||
|
|
||||
|
} // Namespace Common
|
||||
@ -0,0 +1,46 @@ |
|||||
|
// Copyright 2013 Dolphin Emulator Project |
||||
|
// Licensed under GPLv2 |
||||
|
// Refer to the license.txt file included. |
||||
|
|
||||
|
#ifndef _TIMER_H_ |
||||
|
#define _TIMER_H_ |
||||
|
|
||||
|
#include "common.h" |
||||
|
#include <string> |
||||
|
|
||||
|
namespace Common |
||||
|
{ |
||||
|
class Timer |
||||
|
{ |
||||
|
public: |
||||
|
Timer(); |
||||
|
|
||||
|
void Start(); |
||||
|
void Stop(); |
||||
|
void Update(); |
||||
|
|
||||
|
// The time difference is always returned in milliseconds, regardless of alternative internal representation |
||||
|
u64 GetTimeDifference(); |
||||
|
void AddTimeDifference(); |
||||
|
|
||||
|
static void IncreaseResolution(); |
||||
|
static void RestoreResolution(); |
||||
|
static u64 GetTimeSinceJan1970(); |
||||
|
static u64 GetLocalTimeSinceJan1970(); |
||||
|
static double GetDoubleTime(); |
||||
|
|
||||
|
static std::string GetTimeFormatted(); |
||||
|
std::string GetTimeElapsedFormatted() const; |
||||
|
u64 GetTimeElapsed(); |
||||
|
|
||||
|
static u32 GetTimeMs(); |
||||
|
|
||||
|
private: |
||||
|
u64 m_LastTime; |
||||
|
u64 m_StartTime; |
||||
|
bool m_Running; |
||||
|
}; |
||||
|
|
||||
|
} // Namespace Common |
||||
|
|
||||
|
#endif // _TIMER_H_ |
||||
@ -0,0 +1,45 @@ |
|||||
|
// Copyright 2013 Dolphin Emulator Project
|
||||
|
// Licensed under GPLv2
|
||||
|
// Refer to the license.txt file included.
|
||||
|
|
||||
|
#include "common.h"
|
||||
|
#include "scm_rev.h"
|
||||
|
|
||||
|
#ifdef _DEBUG
|
||||
|
#define BUILD_TYPE_STR "Debug "
|
||||
|
#elif defined DEBUGFAST
|
||||
|
#define BUILD_TYPE_STR "DebugFast "
|
||||
|
#else
|
||||
|
#define BUILD_TYPE_STR ""
|
||||
|
#endif
|
||||
|
|
||||
|
const char *scm_rev_str = "Dolphin " |
||||
|
#if !SCM_IS_MASTER
|
||||
|
"[" SCM_BRANCH_STR "] " |
||||
|
#endif
|
||||
|
|
||||
|
#ifdef __INTEL_COMPILER
|
||||
|
BUILD_TYPE_STR SCM_DESC_STR "-ICC"; |
||||
|
#else
|
||||
|
BUILD_TYPE_STR SCM_DESC_STR; |
||||
|
#endif
|
||||
|
|
||||
|
#ifdef _M_X64
|
||||
|
#define NP_ARCH "x64"
|
||||
|
#else
|
||||
|
#ifdef _M_ARM
|
||||
|
#define NP_ARCH "ARM"
|
||||
|
#else
|
||||
|
#define NP_ARCH "x86"
|
||||
|
#endif
|
||||
|
#endif
|
||||
|
|
||||
|
#ifdef _WIN32
|
||||
|
const char *netplay_dolphin_ver = SCM_DESC_STR " W" NP_ARCH; |
||||
|
#elif __APPLE__
|
||||
|
const char *netplay_dolphin_ver = SCM_DESC_STR " M" NP_ARCH; |
||||
|
#else
|
||||
|
const char *netplay_dolphin_ver = SCM_DESC_STR " L" NP_ARCH; |
||||
|
#endif
|
||||
|
|
||||
|
const char *scm_rev_git_str = SCM_REV_STR; |
||||
Write
Preview
Loading…
Cancel
Save
Reference in new issue